home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 January / macformat-020.iso / Shareware City / Developers / OutOfPhase1.01Source / OutOfPhase Folder / BuildInstrument.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-01  |  109.8 KB  |  3,580 lines  |  [TEXT/KAHL]
  1. /* BuildInstrument.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #include "BuildInstrument.h"
  31. #include "Memory.h"
  32. #include "TrashTracker.h"
  33. #include "CompilerScanner.h"
  34. #include "InstrumentStructure.h"
  35. #include "OscillatorSpecifier.h"
  36. #include "OscillatorListSpecifier.h"
  37. #include "LFOSpecifier.h"
  38. #include "LFOListSpecifier.h"
  39. #include "FixedPoint.h"
  40. #include "DataMunging.h"
  41. #include "Envelope.h"
  42. #include "SampleSelector.h"
  43. #include "ModulationSpecifier.h"
  44.  
  45.  
  46.  
  47.  
  48. #define OPAREN "("
  49. #define CPAREN ")"
  50.  
  51.  
  52.  
  53.  
  54. #define INSTRLIST_ONCEONLY_LOUDNESS (1L << 0)
  55.  
  56. #define INSTRLIST_REQUIRED_LOUDNESS (1L << 0)
  57. #define INSTRLIST_REQUIRED_OSCILLATOR (1L << 1)
  58. #define INSTRLIST_REQUIREDMASK (INSTRLIST_REQUIRED_LOUDNESS\
  59.                     | INSTRLIST_REQUIRED_OSCILLATOR)
  60.  
  61.  
  62. #define LFODEFINITION_ONCEONLY_FREQENVELOPE (1L << 0)
  63. #define LFODEFINITION_ONCEONLY_AMPENVELOPE (1L << 1)
  64. #define LFODEFINITION_ONCEONLY_OSCILLATORTYPE (1L << 2)
  65. #define LFODEFINITION_ONCEONLY_MODULATIONTYPE (1L << 3)
  66. #define LFODEFINITION_ONCEONLY_ADDINGMODE (1L << 4)
  67.  
  68. #define LFODEFINITION_REQUIRED_FREQENVELOPE (1L << 0)
  69. #define LFODEFINITION_REQUIRED_AMPENVELOPE (1L << 1)
  70. #define LFODEFINITION_REQUIREDMASK (LFODEFINITION_REQUIRED_FREQENVELOPE\
  71.                     | LFODEFINITION_REQUIRED_AMPENVELOPE)
  72.  
  73.  
  74. #define OSCILLATORDEFINITION_ONCEONLY_TYPE (1L << 0)
  75. #define OSCILLATORDEFINITION_ONCEONLY_SAMPLELIST (1L << 1)
  76. #define OSCILLATORDEFINITION_ONCEONLY_MODULATORS (1L << 2)
  77. #define OSCILLATORDEFINITION_ONCEONLY_LOUDNESS (1L << 3)
  78. #define OSCILLATORDEFINITION_ONCEONLY_FREQMULTIPLIER (1L << 4)
  79. #define OSCILLATORDEFINITION_ONCEONLY_FREQDIVISOR (1L << 5)
  80. #define OSCILLATORDEFINITION_ONCEONLY_MAKEOUTPUT (1L << 6)
  81. #define OSCILLATORDEFINITION_ONCEONLY_LOUDNESSENVELOPE (1L << 7)
  82. #define OSCILLATORDEFINITION_ONCEONLY_INDEXENVELOPE (1L << 8)
  83. #define OSCILLATORDEFINITION_ONCEONLY_STEREOBIAS (1L << 9)
  84. #define OSCILLATORDEFINITION_ONCEONLY_TIMEDISPLACEMENT (1L << 10)
  85. #define OSCILLATORDEFINITION_ONCEONLY_SURROUNDBIAS (1L << 11)
  86.  
  87. #define OSCILLATORDEFINITION_REQUIRED_TYPE (1L << 0)
  88. #define OSCILLATORDEFINITION_REQUIRED_LOUDNESS (1L << 1)
  89. #define OSCILLATORDEFINITION_REQUIRED_LOUDNESSENVELOPE (1L << 2)
  90. #define OSCILLATORDEFINITION_REQUIRED_SAMPLELIST (1L << 3)
  91.  
  92. #define OSCILLATORDEFINITION_REQUIREDMASK (OSCILLATORDEFINITION_REQUIRED_TYPE\
  93.                     | OSCILLATORDEFINITION_REQUIRED_LOUDNESS\
  94.                     | OSCILLATORDEFINITION_REQUIRED_LOUDNESSENVELOPE\
  95.                     | OSCILLATORDEFINITION_REQUIRED_SAMPLELIST)
  96.  
  97.  
  98. #define ENVELOPEDEFINITION_ONCEONLY_TOTALSCALING (1L << 1)
  99. #define ENVELOPEDEFINITION_ONCEONLY_POINTS (1L << 2)
  100.  
  101. #define ENVELOPEDEFINITION_REQUIREDMASK (0L)
  102.  
  103.  
  104. #define ENVPOINTDEFINITION_ONCEONLY_AMPACCENT1 (1L << 0)
  105. #define ENVPOINTDEFINITION_ONCEONLY_AMPACCENT2 (1L << 1)
  106. #define ENVPOINTDEFINITION_ONCEONLY_AMPACCENT3 (1L << 2)
  107. #define ENVPOINTDEFINITION_ONCEONLY_AMPACCENT4 (1L << 3)
  108. #define ENVPOINTDEFINITION_ONCEONLY_AMPFREQ (1L << 4)
  109. #define ENVPOINTDEFINITION_ONCEONLY_RATEACCENT1 (1L << 5)
  110. #define ENVPOINTDEFINITION_ONCEONLY_RATEACCENT2 (1L << 6)
  111. #define ENVPOINTDEFINITION_ONCEONLY_RATEACCENT3 (1L << 7)
  112. #define ENVPOINTDEFINITION_ONCEONLY_RATEACCENT4 (1L << 8)
  113. #define ENVPOINTDEFINITION_ONCEONLY_RATEFREQ (1L << 9)
  114. #define ENVPOINTDEFINITION_ONCEONLY_CURVE (1L << 10)
  115.  
  116.  
  117.  
  118.  
  119. /* prototypes */
  120. static BuildInstrErrors            ParseInstrDefinition(InstrumentRec* Instrument,
  121.                                                             ScannerRec* Scanner, long* ErrorLine,
  122.                                                             struct SampleListRec* SampleList,
  123.                                                             struct AlgoSampListRec* AlgoSampList,
  124.                                                             struct WaveTableListRec* WaveTableList,
  125.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  126. static BuildInstrErrors            ParseInstrList(InstrumentRec* Instrument,
  127.                                                             ScannerRec* Scanner, long* ErrorLine,
  128.                                                             unsigned long* RequiredDefinitions,
  129.                                                             unsigned long OnceOnlyDefinitions,
  130.                                                             struct SampleListRec* SampleList,
  131.                                                             struct AlgoSampListRec* AlgoSampList,
  132.                                                             struct WaveTableListRec* WaveTableList,
  133.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  134. static BuildInstrErrors            ParseInstrElem(InstrumentRec* Instrument,
  135.                                                             ScannerRec* Scanner, long* ErrorLine,
  136.                                                             unsigned long* RequiredDefinitions,
  137.                                                             unsigned long* OnceOnlyDefinitions,
  138.                                                             struct SampleListRec* SampleList,
  139.                                                             struct AlgoSampListRec* AlgoSampList,
  140.                                                             struct WaveTableListRec* WaveTableList,
  141.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  142. static BuildInstrErrors            ParseNumber(ScannerRec* Scanner, long* ErrorLine,
  143.                                                             double* NumberOut);
  144. static BuildInstrErrors            ParseLfoDefinition(LFOSpecRec* LFO, ScannerRec* Scanner,
  145.                                                             long* ErrorLine, unsigned long* RequiredDefinitions,
  146.                                                             unsigned long OnceOnlyDefinitions,
  147.                                                             struct WaveTableListRec* WaveTableList,
  148.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  149. static BuildInstrErrors            ParseIdentifier(ScannerRec* Scanner, long* ErrorLine,
  150.                                                             char** IdentifierOut);
  151. static BuildInstrErrors            ParseOscillatorDefinition(OscillatorRec* Oscillator,
  152.                                                             ScannerRec* Scanner, long* ErrorLine,
  153.                                                             unsigned long* RequiredDefinitions,
  154.                                                             unsigned long OnceOnlyDefinitions,
  155.                                                             struct WaveTableListRec* WaveTableList,
  156.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  157. static BuildInstrErrors            ParseLfoElem(LFOSpecRec* LFO, ScannerRec* Scanner,
  158.                                                             long* ErrorLine, unsigned long* RequiredDefinitions,
  159.                                                             unsigned long* OnceOnlyDefinitions,
  160.                                                             struct WaveTableListRec* WaveTableList,
  161.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  162. static BuildInstrErrors            ParseOscillatorElem(OscillatorRec* Oscillator,
  163.                                                             ScannerRec* Scanner, long* ErrorLine,
  164.                                                             unsigned long* RequiredDefinitions,
  165.                                                             unsigned long* OnceOnlyDefinitions,
  166.                                                             struct WaveTableListRec* WaveTableList,
  167.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  168. static BuildInstrErrors            ParseEnvelopeDefinition(EnvelopeRec* Envelope,
  169.                                                             ScannerRec* Scanner, long* ErrorLine,
  170.                                                             unsigned long* RequiredDefinitions,
  171.                                                             unsigned long OnceOnlyDefinitions);
  172. static BuildInstrErrors            ParseSamplelistDefinition(SampleSelectorRec* SampleList,
  173.                                                             ScannerRec* Scanner, long* ErrorLine);
  174. static BuildInstrErrors            ParseModulatorList(ModulationSpecRec* ModulatorList,
  175.                                                             ScannerRec* Scanner, long* ErrorLine,
  176.                                                             struct WaveTableListRec* WaveTableList,
  177.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  178. static BuildInstrErrors            ParseEnvelopeElem(EnvelopeRec* Envelope,
  179.                                                             ScannerRec* Scanner, long *ErrorLine,
  180.                                                             unsigned long* RequiredDefinitions,
  181.                                                             unsigned long* OnceOnlyDefinitions);
  182. static BuildInstrErrors            ParseSamplelistElem(SampleSelectorRec* SampleList,
  183.                                                             ScannerRec* Scanner, long* ErrorLine);
  184. static BuildInstrErrors            ParseModulatorElem(ModulationSpecRec* ModulatorList,
  185.                                                             ScannerRec* Scanner, long* ErrorLine,
  186.                                                             struct WaveTableListRec* WaveTableList,
  187.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  188. static BuildInstrErrors            ParseEnvPointList(EnvelopeRec* Envelope,
  189.                                                             ScannerRec* Scanner, long *ErrorLine);
  190. static BuildInstrErrors            ParseEnvPointElem(EnvelopeRec* Envelope,
  191.                                                             ScannerRec* Scanner, long *ErrorLine);
  192. static BuildInstrErrors            ParseEnvAttributes(EnvelopeRec* Envelope,
  193.                                                             ScannerRec* Scanner, long *ErrorLine,
  194.                                                             unsigned long OnceOnly);
  195. static BuildInstrErrors            ParseEnvOneAttribute(EnvelopeRec* Envelope,
  196.                                                             ScannerRec* Scanner, long *ErrorLine,
  197.                                                             unsigned long* OnceOnlyDefinitions);
  198. static BuildInstrErrors            ParseModulationDynamic(LFOListSpecRec** LFOListOut,
  199.                                                             EnvelopeRec** EnvelopeOut, ScannerRec* Scanner,
  200.                                                             long* ErrorLine, struct WaveTableListRec* WaveTableList,
  201.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList);
  202.  
  203.  
  204.  
  205.  
  206. /* token enumeration definitions */
  207. typedef enum
  208.     {
  209.         eKeywordInstrument EXECUTE(= -1274),
  210.         eKeywordLoudness,
  211.         eKeywordFrequencylfo,
  212.         eKeywordOscillator,
  213.         eKeywordFreqenvelope,
  214.         eKeywordModulation,
  215.         eKeywordConstant,
  216.         eKeywordSignsine,
  217.         eKeywordPlussine,
  218.         eKeywordSigntriangle,
  219.         eKeywordPlustriangle,
  220.         eKeywordSignsquare,
  221.         eKeywordPlussquare,
  222.         eKeywordSignramp,
  223.         eKeywordPlusramp,
  224.         eKeywordSignlinfuzz,
  225.         eKeywordPluslinfuzz,
  226.         eKeywordAdditive,
  227.         eKeywordMultiplicative,
  228.         eKeywordInversemult,
  229.         eKeywordType,
  230.         eKeywordSampled,
  231.         eKeywordWavetable,
  232.         eKeywordSamplelist,
  233.         eKeywordModulators,
  234.         eKeywordFreqmultiplier,
  235.         eKeywordFreqdivisor,
  236.         eKeywordMakeoutput,
  237.         eKeywordTrue,
  238.         eKeywordFalse,
  239.         eKeywordLoudnessenvelope,
  240.         eKeywordTotalscaling,
  241.         eKeywordExponential,
  242.         eKeywordLinear,
  243.         eKeywordLevel,
  244.         eKeywordDelay,
  245.         eKeywordSustainpoint,
  246.         eKeywordReleasepoint,
  247.         eKeywordSustainpointnoskip,
  248.         eKeywordReleasepointnoskip,
  249.         eKeywordAmpaccent1,
  250.         eKeywordAmpaccent2,
  251.         eKeywordAmpaccent3,
  252.         eKeywordAmpaccent4,
  253.         eKeywordAmpfreq,
  254.         eKeywordRateaccent1,
  255.         eKeywordRateaccent2,
  256.         eKeywordRateaccent3,
  257.         eKeywordRateaccent4,
  258.         eKeywordRatefreq,
  259.         eKeywordSource,
  260.         eKeywordScale,
  261.         eKeywordOriginadjust,
  262.         eKeywordPhasegen,
  263.         eKeywordOutput,
  264.         eKeywordAmpenvelope,
  265.         eKeywordLoudnesslfo,
  266.         eKeywordIndexenvelope,
  267.         eKeywordIndexlfo,
  268.         eKeywordPoints,
  269.         eKeywordTarget,
  270.         eKeywordOrigin,
  271.         eKeywordLfo,
  272.         eKeywordEnvelope,
  273.         eKeywordStereobias,
  274.         eKeywordDisplacement,
  275.         eKeywordSurroundbias
  276.     } KeywordType;
  277.  
  278.  
  279.  
  280.  
  281. /* take a block of text and parse it into an instrument definition.  it returns an */
  282. /* error code.  if an error occurs, then *InstrOut is invalid, otherwise it will */
  283. /* be valid.  the text file remains unaltered.  *ErrorLine is numbered from 1. */
  284. BuildInstrErrors                        BuildInstrumentFromText(char* TextFile, long* ErrorLine,
  285.                                                             struct InstrumentRec** InstrOut,
  286.                                                             struct SampleListRec* SampleList,
  287.                                                             struct AlgoSampListRec* AlgoSampList,
  288.                                                             struct WaveTableListRec* WaveTableList,
  289.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  290.     {
  291.         TrashTrackRec*                        TrashTracker;
  292.         ScannerRec*                                Scanner;
  293.         InstrumentRec*                        Instrument;
  294.         BuildInstrErrors                    Error;
  295.         TokenRec*                                    Token;
  296.  
  297.         CheckPtrExistence(TextFile);
  298.         CheckPtrExistence(SampleList);
  299.         CheckPtrExistence(AlgoSampList);
  300.         CheckPtrExistence(WaveTableList);
  301.         CheckPtrExistence(AlgoWaveTableList);
  302.         EXECUTE(*InstrOut = (InstrumentRec*)0x81818181;)
  303.         EXECUTE(*ErrorLine = 0x81818181;)
  304.  
  305.         TrashTracker = NewTrashTracker();
  306.         if (TrashTracker == NIL)
  307.             {
  308.              NoMemoryFailurePoint1:
  309.                 *ErrorLine = 1;
  310.                 return eBuildInstrOutOfMemory;
  311.             }
  312.  
  313.         Scanner = NewScanner(TrashTracker,TextFile);
  314.         if (Scanner == NIL)
  315.             {
  316.              NoMemoryFailurePoint2:
  317.                 goto NoMemoryFailurePoint1;
  318.             }
  319.  
  320.         Instrument = NewInstrumentSpecifier();
  321.         if (Instrument == NIL)
  322.             {
  323.              NoMemoryFailurePoint3:
  324.                 goto NoMemoryFailurePoint2;
  325.             }
  326.  
  327.         AddKeywordToScanner(Scanner,"instrument",eKeywordInstrument);
  328.         AddKeywordToScanner(Scanner,"loudness",eKeywordLoudness);
  329.         AddKeywordToScanner(Scanner,"frequencylfo",eKeywordFrequencylfo);
  330.         AddKeywordToScanner(Scanner,"oscillator",eKeywordOscillator);
  331.         AddKeywordToScanner(Scanner,"freqenvelope",eKeywordFreqenvelope);
  332.         AddKeywordToScanner(Scanner,"modulation",eKeywordModulation);
  333.         AddKeywordToScanner(Scanner,"constant",eKeywordConstant);
  334.         AddKeywordToScanner(Scanner,"signsine",eKeywordSignsine);
  335.         AddKeywordToScanner(Scanner,"plussine",eKeywordPlussine);
  336.         AddKeywordToScanner(Scanner,"signtriangle",eKeywordSigntriangle);
  337.         AddKeywordToScanner(Scanner,"plustriangle",eKeywordPlustriangle);
  338.         AddKeywordToScanner(Scanner,"signsquare",eKeywordSignsquare);
  339.         AddKeywordToScanner(Scanner,"plussquare",eKeywordPlussquare);
  340.         AddKeywordToScanner(Scanner,"signramp",eKeywordSignramp);
  341.         AddKeywordToScanner(Scanner,"plusramp",eKeywordPlusramp);
  342.         AddKeywordToScanner(Scanner,"signlinfuzz",eKeywordSignlinfuzz);
  343.         AddKeywordToScanner(Scanner,"pluslinfuzz",eKeywordPluslinfuzz);
  344.         AddKeywordToScanner(Scanner,"additive",eKeywordAdditive);
  345.         AddKeywordToScanner(Scanner,"multiplicative",eKeywordMultiplicative);
  346.         AddKeywordToScanner(Scanner,"inversemult",eKeywordInversemult);
  347.         AddKeywordToScanner(Scanner,"type",eKeywordType);
  348.         AddKeywordToScanner(Scanner,"sampled",eKeywordSampled);
  349.         AddKeywordToScanner(Scanner,"wavetable",eKeywordWavetable);
  350.         AddKeywordToScanner(Scanner,"samplelist",eKeywordSamplelist);
  351.         AddKeywordToScanner(Scanner,"modulators",eKeywordModulators);
  352.         AddKeywordToScanner(Scanner,"freqmultiplier",eKeywordFreqmultiplier);
  353.         AddKeywordToScanner(Scanner,"freqdivisor",eKeywordFreqdivisor);
  354.         AddKeywordToScanner(Scanner,"makeoutput",eKeywordMakeoutput);
  355.         AddKeywordToScanner(Scanner,"true",eKeywordTrue);
  356.         AddKeywordToScanner(Scanner,"false",eKeywordFalse);
  357.         AddKeywordToScanner(Scanner,"loudnessenvelope",eKeywordLoudnessenvelope);
  358.         AddKeywordToScanner(Scanner,"totalscaling",eKeywordTotalscaling);
  359.         AddKeywordToScanner(Scanner,"exponential",eKeywordExponential);
  360.         AddKeywordToScanner(Scanner,"linear",eKeywordLinear);
  361.         AddKeywordToScanner(Scanner,"level",eKeywordLevel);
  362.         AddKeywordToScanner(Scanner,"delay",eKeywordDelay);
  363.         AddKeywordToScanner(Scanner,"sustainpoint",eKeywordSustainpoint);
  364.         AddKeywordToScanner(Scanner,"releasepoint",eKeywordReleasepoint);
  365.         AddKeywordToScanner(Scanner,"sustainpointnoskip",eKeywordSustainpointnoskip);
  366.         AddKeywordToScanner(Scanner,"releasepointnoskip",eKeywordReleasepointnoskip);
  367.         AddKeywordToScanner(Scanner,"ampaccent1",eKeywordAmpaccent1);
  368.         AddKeywordToScanner(Scanner,"ampaccent2",eKeywordAmpaccent2);
  369.         AddKeywordToScanner(Scanner,"ampaccent3",eKeywordAmpaccent3);
  370.         AddKeywordToScanner(Scanner,"ampaccent4",eKeywordAmpaccent4);
  371.         AddKeywordToScanner(Scanner,"ampfreq",eKeywordAmpfreq);
  372.         AddKeywordToScanner(Scanner,"rateaccent1",eKeywordRateaccent1);
  373.         AddKeywordToScanner(Scanner,"rateaccent2",eKeywordRateaccent2);
  374.         AddKeywordToScanner(Scanner,"rateaccent3",eKeywordRateaccent3);
  375.         AddKeywordToScanner(Scanner,"rateaccent4",eKeywordRateaccent4);
  376.         AddKeywordToScanner(Scanner,"ratefreq",eKeywordRatefreq);
  377.         AddKeywordToScanner(Scanner,"source",eKeywordSource);
  378.         AddKeywordToScanner(Scanner,"scale",eKeywordScale);
  379.         AddKeywordToScanner(Scanner,"originadjust",eKeywordOriginadjust);
  380.         AddKeywordToScanner(Scanner,"phasegen",eKeywordPhasegen);
  381.         AddKeywordToScanner(Scanner,"output",eKeywordOutput);
  382.         AddKeywordToScanner(Scanner,"ampenvelope",eKeywordAmpenvelope);
  383.         AddKeywordToScanner(Scanner,"loudnesslfo",eKeywordLoudnesslfo);
  384.         AddKeywordToScanner(Scanner,"indexenvelope",eKeywordIndexenvelope);
  385.         AddKeywordToScanner(Scanner,"indexlfo",eKeywordIndexlfo);
  386.         AddKeywordToScanner(Scanner,"points",eKeywordPoints);
  387.         AddKeywordToScanner(Scanner,"target",eKeywordTarget);
  388.         AddKeywordToScanner(Scanner,"origin",eKeywordOrigin);
  389.         AddKeywordToScanner(Scanner,"lfo",eKeywordLfo);
  390.         AddKeywordToScanner(Scanner,"envelope",eKeywordEnvelope);
  391.         AddKeywordToScanner(Scanner,"stereobias",eKeywordStereobias);
  392.         AddKeywordToScanner(Scanner,"displacement",eKeywordDisplacement);
  393.         AddKeywordToScanner(Scanner,"surroundbias",eKeywordSurroundbias);
  394.  
  395.         Error = ParseInstrDefinition(Instrument,Scanner,ErrorLine,SampleList,AlgoSampList,
  396.             WaveTableList,AlgoWaveTableList);
  397.         if (Error != eBuildInstrNoError)
  398.             {
  399.                 DisposeInstrumentSpecification(Instrument);
  400.                 DisposeTrashTracker(TrashTracker);
  401.                 return Error;
  402.             }
  403.         if (!ResolveInstrOscillatorModulations(Instrument))
  404.             {
  405.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  406.                 DisposeInstrumentSpecification(Instrument);
  407.                 DisposeTrashTracker(TrashTracker);
  408.                 return eBuildInstrUnresolvedOscillatorReferences;
  409.             }
  410.  
  411.         Token = GetNextToken(Scanner);
  412.         if (Token == NIL)
  413.             {
  414.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  415.                 DisposeInstrumentSpecification(Instrument);
  416.                 DisposeTrashTracker(TrashTracker);
  417.                 return eBuildInstrOutOfMemory;
  418.             }
  419.         if (GetTokenType(Token) != eTokenEndOfInput)
  420.             {
  421.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  422.                 DisposeInstrumentSpecification(Instrument);
  423.                 DisposeTrashTracker(TrashTracker);
  424.                 return eBuildInstrUnexpectedInput;
  425.             }
  426.  
  427.         DisposeTrashTracker(TrashTracker);
  428.  
  429.         *InstrOut = Instrument;
  430.         return eBuildInstrNoError;
  431.     }
  432.  
  433.  
  434.  
  435.  
  436. /*    1:   <instr_definition>      ::= instrument ( <instr_list> ) */
  437. /* FIRST SET: */
  438. /*  <instr_definition>      : {instrument} */
  439. /* FOLLOW SET: */
  440. /*  <instr_definition>      : {$$$} */
  441. static BuildInstrErrors            ParseInstrDefinition(InstrumentRec* Instrument,
  442.                                                             ScannerRec* Scanner, long* ErrorLine,
  443.                                                             struct SampleListRec* SampleList,
  444.                                                             struct AlgoSampListRec* AlgoSampList,
  445.                                                             struct WaveTableListRec* WaveTableList,
  446.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  447.     {
  448.         TokenRec*                                    Token;
  449.         BuildInstrErrors                    Error;
  450.         unsigned long                            Required;
  451.  
  452.         CheckPtrExistence(Instrument);
  453.         CheckPtrExistence(Scanner);
  454.  
  455.         Token = GetNextToken(Scanner);
  456.         if (Token == NIL)
  457.             {
  458.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  459.                 return eBuildInstrOutOfMemory;
  460.             }
  461.         if ((GetTokenType(Token) != eTokenKeyword)
  462.             || (GetTokenKeywordTag(Token) != eKeywordInstrument))
  463.             {
  464.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  465.                 return eBuildInstrExpectedInstrument;
  466.             }
  467.  
  468.         Token = GetNextToken(Scanner);
  469.         if (Token == NIL)
  470.             {
  471.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  472.                 return eBuildInstrOutOfMemory;
  473.             }
  474.         if (GetTokenType(Token) != eTokenOpenParen)
  475.             {
  476.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  477.                 return eBuildInstrExpectedOpenParen;
  478.             }
  479.  
  480.         Required = 0;
  481.         Error = ParseInstrList(Instrument,Scanner,ErrorLine,&Required,0,SampleList,
  482.             AlgoSampList,WaveTableList,AlgoWaveTableList);
  483.         if (Error != eBuildInstrNoError)
  484.             {
  485.                 return Error;
  486.             }
  487.         if (Required != INSTRLIST_REQUIREDMASK)
  488.             {
  489.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  490.                 return eBuildInstrSomeRequiredInstrParamsMissing;
  491.             }
  492.  
  493.         Token = GetNextToken(Scanner);
  494.         if (Token == NIL)
  495.             {
  496.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  497.                 return eBuildInstrOutOfMemory;
  498.             }
  499.         if (GetTokenType(Token) != eTokenCloseParen)
  500.             {
  501.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  502.                 return eBuildInstrExpectedCloseParen;
  503.             }
  504.  
  505.         return eBuildInstrNoError;
  506.     }
  507.  
  508.  
  509.  
  510.  
  511. /*    2:   <instr_list>            ::= <instr_elem> ; <instr_list> */
  512. /*    3:                           ::=  */
  513. /* FIRST SET: */
  514. /*  <instr_list>            : {loudness, frequencylfo, oscillator, <instr_elem>} */
  515. /* FOLLOW SET: */
  516. /*  <instr_list>            : {)} */
  517. static BuildInstrErrors            ParseInstrList(InstrumentRec* Instrument,
  518.                                                             ScannerRec* Scanner, long* ErrorLine,
  519.                                                             unsigned long* RequiredDefinitions,
  520.                                                             unsigned long OnceOnlyDefinitions,
  521.                                                             struct SampleListRec* SampleList,
  522.                                                             struct AlgoSampListRec* AlgoSampList,
  523.                                                             struct WaveTableListRec* WaveTableList,
  524.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  525.     {
  526.         TokenRec*                                    Token;
  527.         BuildInstrErrors                    Error;
  528.  
  529.         CheckPtrExistence(Instrument);
  530.         CheckPtrExistence(Scanner);
  531.  
  532.         Token = GetNextToken(Scanner);
  533.         if (Token == NIL)
  534.             {
  535.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  536.                 return eBuildInstrOutOfMemory;
  537.             }
  538.  
  539.         if (GetTokenType(Token) == eTokenCloseParen)
  540.             {
  541.                 UngetToken(Scanner,Token);
  542.                 return eBuildInstrNoError;
  543.             }
  544.          else
  545.             {
  546.                 UngetToken(Scanner,Token);
  547.  
  548.                 Error = ParseInstrElem(Instrument,Scanner,ErrorLine,RequiredDefinitions,
  549.                     &OnceOnlyDefinitions,SampleList,AlgoSampList,WaveTableList,AlgoWaveTableList);
  550.                 if (Error != eBuildInstrNoError)
  551.                     {
  552.                         return Error;
  553.                     }
  554.  
  555.                 /* get semicolon */
  556.                 Token = GetNextToken(Scanner);
  557.                 if (Token == NIL)
  558.                     {
  559.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  560.                         return eBuildInstrOutOfMemory;
  561.                     }
  562.                 if (GetTokenType(Token) != eTokenSemicolon)
  563.                     {
  564.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  565.                         return eBuildInstrExpectedSemicolon;
  566.                     }
  567.  
  568.                 return ParseInstrList(Instrument,Scanner,ErrorLine,RequiredDefinitions,
  569.                     OnceOnlyDefinitions,SampleList,AlgoSampList,WaveTableList,AlgoWaveTableList);
  570.             }
  571.         EXECUTE(PRERR(ForceAbort,"ParseInstrList:  control reached end of function"));
  572.     }
  573.  
  574.  
  575.  
  576.  
  577. /*    4:   <instr_elem>            ::= loudness <number> */
  578. /*    5:                           ::= frequencylfo ( <lfo_definition> ) */
  579. /*    6:                           ::= oscillator <identifier> ( <oscillator_definition> ) */
  580. /* FIRST SET: */
  581. /*  <instr_elem>            : {loudness, frequencylfo, oscillator} */
  582. /* FOLLOW SET: */
  583. /*  <instr_elem>            : {;} */
  584. static BuildInstrErrors            ParseInstrElem(InstrumentRec* Instrument,
  585.                                                             ScannerRec* Scanner, long* ErrorLine,
  586.                                                             unsigned long* RequiredDefinitions,
  587.                                                             unsigned long* OnceOnlyDefinitions,
  588.                                                             struct SampleListRec* SampleList,
  589.                                                             struct AlgoSampListRec* AlgoSampList,
  590.                                                             struct WaveTableListRec* WaveTableList,
  591.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  592.     {
  593.         TokenRec*                                    Token;
  594.         BuildInstrErrors                    Error;
  595.  
  596.         CheckPtrExistence(Instrument);
  597.         CheckPtrExistence(Scanner);
  598.  
  599.         Token = GetNextToken(Scanner);
  600.         if (Token == NIL)
  601.             {
  602.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  603.                 return eBuildInstrOutOfMemory;
  604.             }
  605.         if (GetTokenType(Token) != eTokenKeyword)
  606.             {
  607.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  608.                 return eBuildInstrExpectedInstrumentMember;
  609.             }
  610.  
  611.         if (GetTokenKeywordTag(Token) == eKeywordLoudness)
  612.             {
  613.                 double                                        Number;
  614.  
  615.                 if ((*OnceOnlyDefinitions & INSTRLIST_ONCEONLY_LOUDNESS) != 0)
  616.                     {
  617.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  618.                         return eBuildInstrMultipleInstrLoudness;
  619.                     }
  620.                 Error = ParseNumber(Scanner,ErrorLine,&Number);
  621.                 if (Error != eBuildInstrNoError)
  622.                     {
  623.                         return Error;
  624.                     }
  625.                 InstrumentSetOverallLoudness(Instrument,Number);
  626.                 *OnceOnlyDefinitions |= INSTRLIST_ONCEONLY_LOUDNESS;
  627.                 *RequiredDefinitions |= INSTRLIST_REQUIRED_LOUDNESS;
  628.             }
  629.         else if (GetTokenKeywordTag(Token) == eKeywordFrequencylfo)
  630.             {
  631.                 unsigned long                            LFORequired;
  632.                 LFOSpecRec*                                LFO;
  633.  
  634.                 /* allocate the LFO */
  635.                 LFO = NewLFOSpecifier();
  636.                 if (LFO == NIL)
  637.                     {
  638.                      LFOAllocFailurePoint1:
  639.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  640.                         return eBuildInstrOutOfMemory;
  641.                     }
  642.                 if (!LFOListSpecAppendNewEntry(GetInstrumentFrequencyLFOList(Instrument),LFO))
  643.                     {
  644.                      LFOAllocFailurePoint2:
  645.                         DisposeLFOSpecifier(LFO);
  646.                         goto LFOAllocFailurePoint1;
  647.                     }
  648.  
  649.                 /* open paren */
  650.                 Token = GetNextToken(Scanner);
  651.                 if (Token == NIL)
  652.                     {
  653.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  654.                         return eBuildInstrOutOfMemory;
  655.                     }
  656.                 if (GetTokenType(Token) != eTokenOpenParen)
  657.                     {
  658.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  659.                         return eBuildInstrExpectedOpenParen;
  660.                     }
  661.  
  662.                 /* parse the low frequency operator */
  663.                 LFORequired = 0;
  664.                 Error = ParseLfoDefinition(LFO,Scanner,ErrorLine,&LFORequired,0,WaveTableList,
  665.                     AlgoWaveTableList);
  666.                 if (Error != eBuildInstrNoError)
  667.                     {
  668.                         return Error;
  669.                     }
  670.                 if (LFORequired != LFODEFINITION_REQUIREDMASK)
  671.                     {
  672.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  673.                         return eBuildInstrSomeRequiredLFOParamsMissing;
  674.                     }
  675.  
  676.                 /* close paren */
  677.                 Token = GetNextToken(Scanner);
  678.                 if (Token == NIL)
  679.                     {
  680.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  681.                         return eBuildInstrOutOfMemory;
  682.                     }
  683.                 if (GetTokenType(Token) != eTokenCloseParen)
  684.                     {
  685.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  686.                         return eBuildInstrExpectedCloseParen;
  687.                     }
  688.             }
  689.         else if (GetTokenKeywordTag(Token) == eKeywordOscillator)
  690.             {
  691.                 char*                                            Identifier;
  692.                 unsigned long                            OscillatorRequired;
  693.                 OscillatorRec*                        Oscillator;
  694.  
  695.                 /* allocate a new oscillator & add it to the instrument */
  696.                 Oscillator = NewOscillatorSpecifier();
  697.                 if (Oscillator == NIL)
  698.                     {
  699.                      OscillatorAllocFailurePoint1:
  700.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  701.                         return eBuildInstrOutOfMemory;
  702.                     }
  703.                 if (!AppendOscillatorToList(GetInstrumentOscillatorList(Instrument),Oscillator))
  704.                     {
  705.                      OscillatorAllocFailurePoint2:
  706.                         DisposeOscillatorSpecifier(Oscillator);
  707.                         goto OscillatorAllocFailurePoint1;
  708.                     }
  709.  
  710.                 /* get the oscillator's name */
  711.                 Error = ParseIdentifier(Scanner,ErrorLine,&Identifier);
  712.                 if (Error != eBuildInstrNoError)
  713.                     {
  714.                         return Error;
  715.                     }
  716.                 CheckPtrExistence(Identifier);
  717.                 PutOscillatorName(Oscillator,Identifier);
  718.  
  719.                 /* eat the open paren */
  720.                 Token = GetNextToken(Scanner);
  721.                 if (Token == NIL)
  722.                     {
  723.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  724.                         return eBuildInstrOutOfMemory;
  725.                     }
  726.                 if (GetTokenType(Token) != eTokenOpenParen)
  727.                     {
  728.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  729.                         return eBuildInstrExpectedOpenParen;
  730.                     }
  731.  
  732.                 /* parse oscillator */
  733.                 OscillatorRequired = 0;
  734.                 Error = ParseOscillatorDefinition(Oscillator,Scanner,ErrorLine,
  735.                     &OscillatorRequired,0,WaveTableList,AlgoWaveTableList);
  736.                 if (Error != eBuildInstrNoError)
  737.                     {
  738.                         return Error;
  739.                     }
  740.                 if (OscillatorRequired != OSCILLATORDEFINITION_REQUIREDMASK)
  741.                     {
  742.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  743.                         return eBuildInstrSomeRequiredOscillatorParamsMissing;
  744.                     }
  745.  
  746.                 /* resolve sample/wave table data references */
  747.                 switch (OscillatorGetWhatKindItIs(Oscillator))
  748.                     {
  749.                         default:
  750.                             EXECUTE(PRERR(ForceAbort,"ParseInstrElem:  bad oscillator type"));
  751.                             break;
  752.                         case eOscillatorSampled:
  753.                             if (!ResolveSamplesInSampleList(OscillatorGetSampleIntervalList(
  754.                                 Oscillator),SampleList,AlgoSampList))
  755.                                 {
  756.                                     *ErrorLine = GetCurrentLineNumber(Scanner);
  757.                                     return eBuildInstrSomeSamplesDontExist;
  758.                                 }
  759.                             break;
  760.                         case eOscillatorWaveTable:
  761.                             if (!ResolveWaveTablesInSampleList(OscillatorGetSampleIntervalList(
  762.                                 Oscillator),WaveTableList,AlgoWaveTableList))
  763.                                 {
  764.                                     *ErrorLine = GetCurrentLineNumber(Scanner);
  765.                                     return eBuildInstrSomeWaveTablesDontExist;
  766.                                 }
  767.                             break;
  768.                     }
  769.  
  770.                 /* eat the close paren */
  771.                 Token = GetNextToken(Scanner);
  772.                 if (Token == NIL)
  773.                     {
  774.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  775.                         return eBuildInstrOutOfMemory;
  776.                     }
  777.                 if (GetTokenType(Token) != eTokenCloseParen)
  778.                     {
  779.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  780.                         return eBuildInstrExpectedCloseParen;
  781.                     }
  782.  
  783.                 *RequiredDefinitions |= INSTRLIST_REQUIRED_OSCILLATOR;
  784.             }
  785.         else
  786.             {
  787.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  788.                 return eBuildInstrExpectedInstrumentMember;
  789.             }
  790.  
  791.         return eBuildInstrNoError;
  792.     }
  793.  
  794.  
  795.  
  796.  
  797. /*   80:   <number>                ::= <integertoken> */
  798. /*   81:                           ::= <floattoken> */
  799. /* FIRST SET: */
  800. /*  <number>                : {<integertoken>, <floattoken>} */
  801. /* FOLLOW SET: */
  802. /*  <number>                : {<integertoken>, <floattoken>, ), ;, type, */
  803. /*       exponential, linear, to, sustainpoint, ampaccent1, ampaccent2, */
  804. /*       ampaccent3, ampaccent4, ampfreq, rateaccent1, rateaccent2, rateaccent3, */
  805. /*       rateaccent4, ratefreq, originadjust, <number>, <env_point_list>, */
  806. /*       <env_point_elem>, <env_attributes>, <env_one_attribute>} */
  807. static BuildInstrErrors            ParseNumber(ScannerRec* Scanner, long* ErrorLine,
  808.                                                             double* NumberOut)
  809.     {
  810.         TokenRec*                                    Token;
  811.         MyBoolean                                    Negative;
  812.  
  813.         CheckPtrExistence(Scanner);
  814.  
  815.         Negative = False;
  816.  
  817.      GetAnotherToken:
  818.         Token = GetNextToken(Scanner);
  819.         if (Token == NIL)
  820.             {
  821.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  822.                 return eBuildInstrOutOfMemory;
  823.             }
  824.  
  825.         switch (GetTokenType(Token))
  826.             {
  827.                 default:
  828.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  829.                     return eBuildInstrExpectedNumber;
  830.                 case eTokenInteger:
  831.                     *NumberOut = GetTokenIntegerValue(Token);
  832.                     break;
  833.                 case eTokenSingle:
  834.                     *NumberOut = GetTokenSingleValue(Token);
  835.                     break;
  836.                 case eTokenDouble:
  837.                     *NumberOut = GetTokenDoubleValue(Token);
  838.                     break;
  839.                 case eTokenFixed:
  840.                     *NumberOut = largefixed2double(GetTokenFixedValue(Token));
  841.                     break;
  842.                 case eTokenMinus:
  843.                     Negative = !Negative;
  844.                     goto GetAnotherToken;
  845.             }
  846.  
  847.         if (Negative)
  848.             {
  849.                 *NumberOut = - *NumberOut;
  850.             }
  851.  
  852.         return eBuildInstrNoError;
  853.     }
  854.  
  855.  
  856.  
  857.  
  858. /*    7:   <lfo_definition>        ::= <lfo_elem> ; <lfo_definition> */
  859. /*    8:                           ::=  */
  860. /* FIRST SET: */
  861. /*  <lfo_definition>        : {oscillator, freqenvelope, modulation, */
  862. /*       ampenvelope, <lfo_elem>} */
  863. /* FOLLOW SET: */
  864. /*  <lfo_definition>        : {)} */
  865. static BuildInstrErrors            ParseLfoDefinition(LFOSpecRec* LFO, ScannerRec* Scanner,
  866.                                                             long* ErrorLine, unsigned long* RequiredDefinitions,
  867.                                                             unsigned long OnceOnlyDefinitions,
  868.                                                             struct WaveTableListRec* WaveTableList,
  869.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  870.     {
  871.         TokenRec*                                    Token;
  872.         BuildInstrErrors                    Error;
  873.  
  874.         CheckPtrExistence(LFO);
  875.         CheckPtrExistence(Scanner);
  876.  
  877.         Token = GetNextToken(Scanner);
  878.         if (Token == NIL)
  879.             {
  880.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  881.                 return eBuildInstrOutOfMemory;
  882.             }
  883.  
  884.         if (GetTokenType(Token) == eTokenCloseParen)
  885.             {
  886.                 UngetToken(Scanner,Token);
  887.                 return eBuildInstrNoError;
  888.             }
  889.          else
  890.             {
  891.                 UngetToken(Scanner,Token);
  892.  
  893.                 Error = ParseLfoElem(LFO,Scanner,ErrorLine,RequiredDefinitions,
  894.                     &OnceOnlyDefinitions,WaveTableList,AlgoWaveTableList);
  895.                 if (Error != eBuildInstrNoError)
  896.                     {
  897.                         return Error;
  898.                     }
  899.  
  900.                 /* get semicolon */
  901.                 Token = GetNextToken(Scanner);
  902.                 if (Token == NIL)
  903.                     {
  904.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  905.                         return eBuildInstrOutOfMemory;
  906.                     }
  907.                 if (GetTokenType(Token) != eTokenSemicolon)
  908.                     {
  909.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  910.                         return eBuildInstrExpectedSemicolon;
  911.                     }
  912.  
  913.                 return ParseLfoDefinition(LFO,Scanner,ErrorLine,RequiredDefinitions,
  914.                     OnceOnlyDefinitions,WaveTableList,AlgoWaveTableList);
  915.             }
  916.  
  917.         EXECUTE(PRERR(ForceAbort,"ParseLfoDefinition:  control reached end of function"));
  918.     }
  919.  
  920.  
  921.  
  922.  
  923. /* the identifier string returned from here is NOT trash-tracker allocated. */
  924. /*   78:   <identifier>            ::= <identifiertoken> */
  925. /*   79:                           ::= <stringtoken> */
  926. /* FIRST SET: */
  927. /*  <identifier>            : {<identifiertoken>, <stringtoken>} */
  928. /* FOLLOW SET: */
  929. /*  <identifier>            : {<integertoken>, <floattoken>, (, scale, */
  930. /*       <number>} */
  931. static BuildInstrErrors            ParseIdentifier(ScannerRec* Scanner, long* ErrorLine,
  932.                                                             char** IdentifierOut)
  933.     {
  934.         TokenRec*                                    Token;
  935.  
  936.         CheckPtrExistence(Scanner);
  937.  
  938.         Token = GetNextToken(Scanner);
  939.         if (Token == NIL)
  940.             {
  941.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  942.                 return eBuildInstrOutOfMemory;
  943.             }
  944.  
  945.         if (GetTokenType(Token) == eTokenIdentifier)
  946.             {
  947.                 *IdentifierOut = CopyPtr(GetTokenIdentifierString(Token));
  948.             }
  949.         else if (GetTokenType(Token) == eTokenString)
  950.             {
  951.                 *IdentifierOut = CopyPtr(GetTokenStringValue(Token));
  952.             }
  953.         else
  954.             {
  955.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  956.                 return eBuildInstrExpectedStringOrIdentifier;
  957.             }
  958.  
  959.         if (*IdentifierOut == NIL)
  960.             {
  961.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  962.                 return eBuildInstrOutOfMemory;
  963.             }
  964.         SetTag(*IdentifierOut,"BuildInstr: ParseIdentifier");
  965.  
  966.         return eBuildInstrNoError;
  967.     }
  968.  
  969.  
  970.  
  971.  
  972. /*   27:   <oscillator_definition> ::= <oscillator_elem> ; */
  973. /*       <oscillator_definition> */
  974. /*   28:                           ::=  */
  975. /* FIRST SET: */
  976. /*  <oscillator_definition> : {loudness, type, samplelist, modulators, */
  977. /*       freqmultiplier, freqdivisor, makeoutput, loudnessenvelope, */
  978. /*       loudnesslfo, indexenvelope, indexlfo, <oscillator_elem>} */
  979. /* FOLLOW SET: */
  980. /*  <oscillator_definition> : {)} */
  981. static BuildInstrErrors            ParseOscillatorDefinition(OscillatorRec* Oscillator,
  982.                                                             ScannerRec* Scanner, long* ErrorLine,
  983.                                                             unsigned long* RequiredDefinitions,
  984.                                                             unsigned long OnceOnlyDefinitions,
  985.                                                             struct WaveTableListRec* WaveTableList,
  986.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  987.     {
  988.         TokenRec*                                    Token;
  989.         BuildInstrErrors                    Error;
  990.  
  991.         CheckPtrExistence(Oscillator);
  992.         CheckPtrExistence(Scanner);
  993.  
  994.         Token = GetNextToken(Scanner);
  995.         if (Token == NIL)
  996.             {
  997.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  998.                 return eBuildInstrOutOfMemory;
  999.             }
  1000.  
  1001.         if (GetTokenType(Token) == eTokenCloseParen)
  1002.             {
  1003.                 UngetToken(Scanner,Token);
  1004.                 return eBuildInstrNoError;
  1005.             }
  1006.          else
  1007.             {
  1008.                 UngetToken(Scanner,Token);
  1009.  
  1010.                 Error = ParseOscillatorElem(Oscillator,Scanner,ErrorLine,RequiredDefinitions,
  1011.                     &OnceOnlyDefinitions,WaveTableList,AlgoWaveTableList);
  1012.                 if (Error != eBuildInstrNoError)
  1013.                     {
  1014.                         return Error;
  1015.                     }
  1016.  
  1017.                 /* get semicolon */
  1018.                 Token = GetNextToken(Scanner);
  1019.                 if (Token == NIL)
  1020.                     {
  1021.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1022.                         return eBuildInstrOutOfMemory;
  1023.                     }
  1024.                 if (GetTokenType(Token) != eTokenSemicolon)
  1025.                     {
  1026.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1027.                         return eBuildInstrExpectedSemicolon;
  1028.                     }
  1029.  
  1030.                 return ParseOscillatorDefinition(Oscillator,Scanner,ErrorLine,
  1031.                     RequiredDefinitions,OnceOnlyDefinitions,WaveTableList,AlgoWaveTableList);
  1032.             }
  1033.  
  1034.         EXECUTE(PRERR(ForceAbort,"ParseOscillatorDefinition:  control reached end of function"));
  1035.     }
  1036.  
  1037.  
  1038.  
  1039.  
  1040. /*    9:   <lfo_elem>              ::= freqenvelope ( <envelope_definition> ) */
  1041. /*   10:                           ::= ampenvelope ( <envelope_definition> ) */
  1042. /*   11:                           ::= oscillator <oscillator_type> */
  1043. /*   12:                           ::= modulation <modulation_type> */
  1044. /* FIRST SET: */
  1045. /*  <lfo_elem>              : {oscillator, freqenvelope, modulation, ampenvelope} */
  1046. /* FOLLOW SET: */
  1047. /*  <lfo_elem>              : {;} */
  1048. static BuildInstrErrors            ParseLfoElem(LFOSpecRec* LFO, ScannerRec* Scanner,
  1049.                                                             long* ErrorLine, unsigned long* RequiredDefinitions,
  1050.                                                             unsigned long* OnceOnlyDefinitions,
  1051.                                                             struct WaveTableListRec* WaveTableList,
  1052.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  1053.     {
  1054.         TokenRec*                                    Token;
  1055.         BuildInstrErrors                    Error;
  1056.         unsigned long                            Required;
  1057.  
  1058.         CheckPtrExistence(LFO);
  1059.         CheckPtrExistence(Scanner);
  1060.  
  1061.         Token = GetNextToken(Scanner);
  1062.         if (Token == NIL)
  1063.             {
  1064.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1065.                 return eBuildInstrOutOfMemory;
  1066.             }
  1067.         if (GetTokenType(Token) != eTokenKeyword)
  1068.             {
  1069.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1070.                 return eBuildInstrExpectedLFOMember;
  1071.             }
  1072.  
  1073.         switch (GetTokenKeywordTag(Token))
  1074.             {
  1075.                 default:
  1076.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  1077.                     return eBuildInstrExpectedLFOMember;
  1078.  
  1079.                 case eKeywordFreqenvelope:
  1080.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_FREQENVELOPE) != 0)
  1081.                         {
  1082.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1083.                             return eBuildInstrMultipleLFOFreqEnvelope;
  1084.                         }
  1085.  
  1086.                     /* open paren */
  1087.                     Token = GetNextToken(Scanner);
  1088.                     if (Token == NIL)
  1089.                         {
  1090.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1091.                             return eBuildInstrOutOfMemory;
  1092.                         }
  1093.                     if (GetTokenType(Token) != eTokenOpenParen)
  1094.                         {
  1095.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1096.                             return eBuildInstrExpectedOpenParen;
  1097.                         }
  1098.  
  1099.                     Required = 0;
  1100.                     Error = ParseEnvelopeDefinition(GetLFOSpecFrequencyEnvelope(LFO),
  1101.                         Scanner,ErrorLine,&Required,0);
  1102.                     if (Error != eBuildInstrNoError)
  1103.                         {
  1104.                             return Error;
  1105.                         }
  1106.                     if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  1107.                         {
  1108.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1109.                             return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1110.                         }
  1111.  
  1112.                     /* close paren */
  1113.                     Token = GetNextToken(Scanner);
  1114.                     if (Token == NIL)
  1115.                         {
  1116.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1117.                             return eBuildInstrOutOfMemory;
  1118.                         }
  1119.                     if (GetTokenType(Token) != eTokenCloseParen)
  1120.                         {
  1121.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1122.                             return eBuildInstrExpectedCloseParen;
  1123.                         }
  1124.  
  1125.                     *RequiredDefinitions |= LFODEFINITION_REQUIRED_FREQENVELOPE;
  1126.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_FREQENVELOPE;
  1127.                     break;
  1128.  
  1129.                 case eKeywordAmpenvelope:
  1130.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_AMPENVELOPE) != 0)
  1131.                         {
  1132.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1133.                             return eBuildInstrMultipleLFOAmpEnvelope;
  1134.                         }
  1135.  
  1136.                     /* open paren */
  1137.                     Token = GetNextToken(Scanner);
  1138.                     if (Token == NIL)
  1139.                         {
  1140.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1141.                             return eBuildInstrOutOfMemory;
  1142.                         }
  1143.                     if (GetTokenType(Token) != eTokenOpenParen)
  1144.                         {
  1145.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1146.                             return eBuildInstrExpectedOpenParen;
  1147.                         }
  1148.  
  1149.                     Required = 0;
  1150.                     Error = ParseEnvelopeDefinition(GetLFOSpecAmplitudeEnvelope(LFO),
  1151.                         Scanner,ErrorLine,&Required,0);
  1152.                     if (Error != eBuildInstrNoError)
  1153.                         {
  1154.                             return Error;
  1155.                         }
  1156.                     if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  1157.                         {
  1158.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1159.                             return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1160.                         }
  1161.  
  1162.                     /* close paren */
  1163.                     Token = GetNextToken(Scanner);
  1164.                     if (Token == NIL)
  1165.                         {
  1166.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1167.                             return eBuildInstrOutOfMemory;
  1168.                         }
  1169.                     if (GetTokenType(Token) != eTokenCloseParen)
  1170.                         {
  1171.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1172.                             return eBuildInstrExpectedCloseParen;
  1173.                         }
  1174.  
  1175.                     *RequiredDefinitions |= LFODEFINITION_REQUIRED_AMPENVELOPE;
  1176.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_AMPENVELOPE;
  1177.                     break;
  1178.  
  1179.                 case eKeywordOscillator:
  1180.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_OSCILLATORTYPE) != 0)
  1181.                         {
  1182.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1183.                             return eBuildInstrMultipleLFOOscillatorType;
  1184.                         }
  1185.  
  1186.                     /*  13:   <oscillator_type>       ::= constant */
  1187.                     /*  14:                           ::= signsine */
  1188.                     /*  15:                           ::= plussine */
  1189.                     /*  16:                           ::= signtriangle */
  1190.                     /*  17:                           ::= plustriangle */
  1191.                     /*  18:                           ::= signsquare */
  1192.                     /*  19:                           ::= plussquare */
  1193.                     /*  20:                           ::= signramp */
  1194.                     /*  21:                           ::= plusramp */
  1195.                     /*  22:                           ::= signlinfuzz */
  1196.                     /*  23:                           ::= pluslinfuzz */
  1197.                     /*  XX:                           ::= wavetable ( <samplelist_definition> */
  1198.                     /*                                    ) ( <envelope_definition> ) */
  1199.                     Token = GetNextToken(Scanner);
  1200.                     if (Token == NIL)
  1201.                         {
  1202.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1203.                             return eBuildInstrOutOfMemory;
  1204.                         }
  1205.                     if (GetTokenType(Token) != eTokenKeyword)
  1206.                         {
  1207.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1208.                             return eBuildInstrExpectedLFOOscillatorType;
  1209.                         }
  1210.                     switch (GetTokenKeywordTag(Token))
  1211.                         {
  1212.                             default:
  1213.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1214.                                 return eBuildInstrExpectedLFOOscillatorType;
  1215.                             case eKeywordConstant:
  1216.                                 SetLFOSpecOscillatorType(LFO,eLFOConstant1);
  1217.                                 break;
  1218.                             case eKeywordSignsine:
  1219.                                 SetLFOSpecOscillatorType(LFO,eLFOSignedSine);
  1220.                                 break;
  1221.                             case eKeywordPlussine:
  1222.                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveSine);
  1223.                                 break;
  1224.                             case eKeywordSigntriangle:
  1225.                                 SetLFOSpecOscillatorType(LFO,eLFOSignedTriangle);
  1226.                                 break;
  1227.                             case eKeywordPlustriangle:
  1228.                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveTriangle);
  1229.                                 break;
  1230.                             case eKeywordSignsquare:
  1231.                                 SetLFOSpecOscillatorType(LFO,eLFOSignedSquare);
  1232.                                 break;
  1233.                             case eKeywordPlussquare:
  1234.                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveSquare);
  1235.                                 break;
  1236.                             case eKeywordSignramp:
  1237.                                 SetLFOSpecOscillatorType(LFO,eLFOSignedRamp);
  1238.                                 break;
  1239.                             case eKeywordPlusramp:
  1240.                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveRamp);
  1241.                                 break;
  1242.                             case eKeywordSignlinfuzz:
  1243.                                 SetLFOSpecOscillatorType(LFO,eLFOSignedLinearFuzz);
  1244.                                 break;
  1245.                             case eKeywordPluslinfuzz:
  1246.                                 SetLFOSpecOscillatorType(LFO,eLFOPositiveLinearFuzz);
  1247.                                 break;
  1248.  
  1249.  
  1250.                             case eKeywordWavetable:
  1251.                                 SetLFOSpecOscillatorType(LFO,eLFOWaveTable);
  1252.  
  1253.                                 /* open paren */
  1254.                                 Token = GetNextToken(Scanner);
  1255.                                 if (Token == NIL)
  1256.                                     {
  1257.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1258.                                         return eBuildInstrOutOfMemory;
  1259.                                     }
  1260.                                 if (GetTokenType(Token) != eTokenOpenParen)
  1261.                                     {
  1262.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1263.                                         return eBuildInstrExpectedOpenParen;
  1264.                                     }
  1265.  
  1266.                                 Error = ParseSamplelistDefinition(GetLFOSpecSampleSelector(LFO),
  1267.                                     Scanner,ErrorLine);
  1268.                                 if (Error != eBuildInstrNoError)
  1269.                                     {
  1270.                                         return Error;
  1271.                                     }
  1272.                                 if (!ResolveWaveTablesInSampleList(GetLFOSpecSampleSelector(LFO),
  1273.                                     WaveTableList,AlgoWaveTableList))
  1274.                                     {
  1275.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1276.                                         return eBuildInstrSomeWaveTablesDontExist;
  1277.                                     }
  1278.  
  1279.                                 /* close paren */
  1280.                                 Token = GetNextToken(Scanner);
  1281.                                 if (Token == NIL)
  1282.                                     {
  1283.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1284.                                         return eBuildInstrOutOfMemory;
  1285.                                     }
  1286.                                 if (GetTokenType(Token) != eTokenCloseParen)
  1287.                                     {
  1288.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1289.                                         return eBuildInstrExpectedCloseParen;
  1290.                                     }
  1291.  
  1292.                                 /* open paren */
  1293.                                 Token = GetNextToken(Scanner);
  1294.                                 if (Token == NIL)
  1295.                                     {
  1296.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1297.                                         return eBuildInstrOutOfMemory;
  1298.                                     }
  1299.                                 if (GetTokenType(Token) != eTokenOpenParen)
  1300.                                     {
  1301.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1302.                                         return eBuildInstrExpectedOpenParen;
  1303.                                     }
  1304.  
  1305.                                 Required = 0;
  1306.                                 Error = ParseEnvelopeDefinition(GetLFOSpecWaveTableIndexEnvelope(LFO),
  1307.                                     Scanner,ErrorLine,&Required,0);
  1308.                                 if (Error != eBuildInstrNoError)
  1309.                                     {
  1310.                                         return Error;
  1311.                                     }
  1312.                                 if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  1313.                                     {
  1314.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1315.                                         return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1316.                                     }
  1317.  
  1318.                                 /* close paren */
  1319.                                 Token = GetNextToken(Scanner);
  1320.                                 if (Token == NIL)
  1321.                                     {
  1322.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1323.                                         return eBuildInstrOutOfMemory;
  1324.                                     }
  1325.                                 if (GetTokenType(Token) != eTokenCloseParen)
  1326.                                     {
  1327.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1328.                                         return eBuildInstrExpectedCloseParen;
  1329.                                     }
  1330.                                 break;
  1331.                         }
  1332.  
  1333.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_OSCILLATORTYPE;
  1334.                     break;
  1335.  
  1336.                 case eKeywordModulation:
  1337.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_MODULATIONTYPE) != 0)
  1338.                         {
  1339.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1340.                             return eBuildInstrMultipleLFOModulationType;
  1341.                         }
  1342.  
  1343.                     /*  24:   <modulation_type>       ::= additive */
  1344.                     /*  25:                           ::= multiplicative */
  1345.                     /*  26:                           ::= inversemult */
  1346.                     Token = GetNextToken(Scanner);
  1347.                     if (Token == NIL)
  1348.                         {
  1349.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1350.                             return eBuildInstrOutOfMemory;
  1351.                         }
  1352.                     if (GetTokenType(Token) != eTokenKeyword)
  1353.                         {
  1354.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1355.                             return eBuildInstrExpectedLFOModulationType;
  1356.                         }
  1357.                     switch (GetTokenKeywordTag(Token))
  1358.                         {
  1359.                             default:
  1360.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1361.                                 return eBuildInstrExpectedLFOModulationType;
  1362.                             case eKeywordAdditive:
  1363.                                 SetLFOSpecModulationMode(LFO,eLFOAdditive);
  1364.                                 break;
  1365.                             case eKeywordMultiplicative:
  1366.                                 SetLFOSpecModulationMode(LFO,eLFOMultiplicative);
  1367.                                 break;
  1368.                             case eKeywordInversemult:
  1369.                                 SetLFOSpecModulationMode(LFO,eLFOInverseMultiplicative);
  1370.                                 break;
  1371.                         }
  1372.  
  1373.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_MODULATIONTYPE;
  1374.                     break;
  1375.  
  1376.                 case eKeywordLinear:
  1377.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_ADDINGMODE) != 0)
  1378.                         {
  1379.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1380.                             return eBuildInstrMultipleLFOAddingMode;
  1381.                         }
  1382.  
  1383.                     SetLFOSpecAddingMode(LFO,eLFOArithmetic);
  1384.  
  1385.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_ADDINGMODE;
  1386.                     break;
  1387.  
  1388.                 case eKeywordExponential:
  1389.                     if ((*OnceOnlyDefinitions & LFODEFINITION_ONCEONLY_ADDINGMODE) != 0)
  1390.                         {
  1391.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1392.                             return eBuildInstrMultipleLFOAddingMode;
  1393.                         }
  1394.  
  1395.                     SetLFOSpecAddingMode(LFO,eLFOGeometric);
  1396.  
  1397.                     *OnceOnlyDefinitions |= LFODEFINITION_ONCEONLY_ADDINGMODE;
  1398.                     break;
  1399.             }
  1400.  
  1401.         return eBuildInstrNoError;
  1402.     }
  1403.  
  1404.  
  1405.  
  1406.  
  1407. /*   29:   <oscillator_elem>       ::= type <oscillator_type> */
  1408. /*   30:                           ::= samplelist ( <samplelist_definition> ) */
  1409. /*   31:                           ::= modulators ( <modulator_list> ) */
  1410. /*   32:                           ::= loudness <number> */
  1411. /*   33:                           ::= freqmultiplier <number> */
  1412. /*   34:                           ::= freqdivisor <integer> */
  1413. /*   35:                           ::= makeoutput <boolean> */
  1414. /*   36:                           ::= loudnessenvelope ( <envelope_definition> ) */
  1415. /*   37:                           ::= loudnesslfo ( <lfo_definition> ) */
  1416. /*   38:                           ::= indexenvelope ( <envelope_definition> ) */
  1417. /*   39:                           ::= indexlfo ( <lfo_definition> ) */
  1418. /*   XXX:                          ::= stereobias <number> */
  1419. /*   XXX:                          ::= displacement <number> */
  1420. /* FIRST SET: */
  1421. /*  <oscillator_elem>       : {loudness, type, samplelist, modulators, */
  1422. /*       freqmultiplier, freqdivisor, makeoutput, loudnessenvelope, */
  1423. /*       loudnesslfo, indexenvelope, indexlfo} */
  1424. /* FOLLOW SET: */
  1425. /*  <oscillator_elem>       : {;} */
  1426. static BuildInstrErrors            ParseOscillatorElem(OscillatorRec* Oscillator,
  1427.                                                             ScannerRec* Scanner, long* ErrorLine,
  1428.                                                             unsigned long* RequiredDefinitions,
  1429.                                                             unsigned long* OnceOnlyDefinitions,
  1430.                                                             struct WaveTableListRec* WaveTableList,
  1431.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  1432.     {
  1433.         TokenRec*                                    Token;
  1434.         BuildInstrErrors                    Error;
  1435.         double                                        Number;
  1436.         unsigned long                            Required;
  1437.  
  1438.         CheckPtrExistence(Oscillator);
  1439.         CheckPtrExistence(Scanner);
  1440.  
  1441.         Token = GetNextToken(Scanner);
  1442.         if (Token == NIL)
  1443.             {
  1444.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1445.                 return eBuildInstrOutOfMemory;
  1446.             }
  1447.         if (GetTokenType(Token) != eTokenKeyword)
  1448.             {
  1449.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1450.                 return eBuildInstrExpectedOscillatorMember;
  1451.             }
  1452.  
  1453.         switch (GetTokenKeywordTag(Token))
  1454.             {
  1455.                 default:
  1456.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  1457.                     return eBuildInstrExpectedOscillatorMember;
  1458.  
  1459.                 case eKeywordType:
  1460.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_TYPE) != 0)
  1461.                         {
  1462.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1463.                             return eBuildInstrMultipleOscType;
  1464.                         }
  1465.  
  1466.                     /*  40:   <oscillator_type>       ::= sampled */
  1467.                     /*  41:                           ::= wavetable */
  1468.                     Token = GetNextToken(Scanner);
  1469.                     if (Token == NIL)
  1470.                         {
  1471.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1472.                             return eBuildInstrOutOfMemory;
  1473.                         }
  1474.                     if (GetTokenType(Token) != eTokenKeyword)
  1475.                         {
  1476.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1477.                             return eBuildInstrExpectedOscType;
  1478.                         }
  1479.                     switch (GetTokenKeywordTag(Token))
  1480.                         {
  1481.                             default:
  1482.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1483.                                 return eBuildInstrExpectedOscType;
  1484.                             case eKeywordSampled:
  1485.                                 OscillatorSetTheType(Oscillator,eOscillatorSampled);
  1486.                                 break;
  1487.                             case eKeywordWavetable:
  1488.                                 OscillatorSetTheType(Oscillator,eOscillatorWaveTable);
  1489.                                 break;
  1490.                         }
  1491.  
  1492.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_TYPE;
  1493.                     *RequiredDefinitions |= OSCILLATORDEFINITION_REQUIRED_TYPE;
  1494.                     break;
  1495.  
  1496.                 case eKeywordSamplelist:
  1497.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_SAMPLELIST) != 0)
  1498.                         {
  1499.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1500.                             return eBuildInstrMultipleOscSampleList;
  1501.                         }
  1502.  
  1503.                     /* open paren */
  1504.                     Token = GetNextToken(Scanner);
  1505.                     if (Token == NIL)
  1506.                         {
  1507.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1508.                             return eBuildInstrOutOfMemory;
  1509.                         }
  1510.                     if (GetTokenType(Token) != eTokenOpenParen)
  1511.                         {
  1512.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1513.                             return eBuildInstrExpectedOpenParen;
  1514.                         }
  1515.  
  1516.                     Error = ParseSamplelistDefinition(OscillatorGetSampleIntervalList(Oscillator),
  1517.                         Scanner,ErrorLine);
  1518.                     if (Error != eBuildInstrNoError)
  1519.                         {
  1520.                             return Error;
  1521.                         }
  1522.  
  1523.                     /* close paren */
  1524.                     Token = GetNextToken(Scanner);
  1525.                     if (Token == NIL)
  1526.                         {
  1527.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1528.                             return eBuildInstrOutOfMemory;
  1529.                         }
  1530.                     if (GetTokenType(Token) != eTokenCloseParen)
  1531.                         {
  1532.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1533.                             return eBuildInstrExpectedCloseParen;
  1534.                         }
  1535.  
  1536.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_SAMPLELIST;
  1537.                     *RequiredDefinitions |= OSCILLATORDEFINITION_REQUIRED_SAMPLELIST;
  1538.                     break;
  1539.  
  1540.                 case eKeywordModulators:
  1541.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_MODULATORS) != 0)
  1542.                         {
  1543.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1544.                             return eBuildInstrMultipleOscModulators;
  1545.                         }
  1546.  
  1547.                     /* open paren */
  1548.                     Token = GetNextToken(Scanner);
  1549.                     if (Token == NIL)
  1550.                         {
  1551.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1552.                             return eBuildInstrOutOfMemory;
  1553.                         }
  1554.                     if (GetTokenType(Token) != eTokenOpenParen)
  1555.                         {
  1556.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1557.                             return eBuildInstrExpectedOpenParen;
  1558.                         }
  1559.  
  1560.                     Error = ParseModulatorList(OscillatorGetModulatorInputList(Oscillator),
  1561.                         Scanner,ErrorLine,WaveTableList,AlgoWaveTableList);
  1562.                     if (Error != eBuildInstrNoError)
  1563.                         {
  1564.                             return Error;
  1565.                         }
  1566.  
  1567.                     /* close paren */
  1568.                     Token = GetNextToken(Scanner);
  1569.                     if (Token == NIL)
  1570.                         {
  1571.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1572.                             return eBuildInstrOutOfMemory;
  1573.                         }
  1574.                     if (GetTokenType(Token) != eTokenCloseParen)
  1575.                         {
  1576.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1577.                             return eBuildInstrExpectedCloseParen;
  1578.                         }
  1579.  
  1580.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_MODULATORS;
  1581.                     break;
  1582.  
  1583.                 case eKeywordLoudness:
  1584.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_LOUDNESS) != 0)
  1585.                         {
  1586.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1587.                             return eBuildInstrMultipleOscLoudness;
  1588.                         }
  1589.  
  1590.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1591.                     if (Error != eBuildInstrNoError)
  1592.                         {
  1593.                             return Error;
  1594.                         }
  1595.                     PutOscillatorNewOutputLoudness(Oscillator,Number);
  1596.  
  1597.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_LOUDNESS;
  1598.                     *RequiredDefinitions |= OSCILLATORDEFINITION_REQUIRED_LOUDNESS;
  1599.                     break;
  1600.  
  1601.                 case eKeywordFreqmultiplier:
  1602.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_FREQMULTIPLIER) != 0)
  1603.                         {
  1604.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1605.                             return eBuildInstrMultipleOscFreqMultiplier;
  1606.                         }
  1607.  
  1608.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1609.                     if (Error != eBuildInstrNoError)
  1610.                         {
  1611.                             return Error;
  1612.                         }
  1613.                     PutOscillatorNewFrequencyFactors(Oscillator,Number,
  1614.                         OscillatorGetFrequencyDivisor(Oscillator));
  1615.  
  1616.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_FREQMULTIPLIER;
  1617.                     break;
  1618.  
  1619.                 case eKeywordFreqdivisor:
  1620.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_FREQDIVISOR) != 0)
  1621.                         {
  1622.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1623.                             return eBuildInstrMultipleOscFreqDivisor;
  1624.                         }
  1625.  
  1626.                     Token = GetNextToken(Scanner);
  1627.                     if (Token == NIL)
  1628.                         {
  1629.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1630.                             return eBuildInstrOutOfMemory;
  1631.                         }
  1632.                     if (GetTokenType(Token) != eTokenInteger)
  1633.                         {
  1634.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1635.                             return eBuildInstrExpectedInteger;
  1636.                         }
  1637.                     PutOscillatorNewFrequencyFactors(Oscillator,
  1638.                         OscillatorGetFrequencyMultiplier(Oscillator),GetTokenIntegerValue(Token));
  1639.  
  1640.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_FREQDIVISOR;
  1641.                     break;
  1642.  
  1643.                 case eKeywordMakeoutput:
  1644.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_MAKEOUTPUT) != 0)
  1645.                         {
  1646.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1647.                             return eBuildInstrMultipleOscMakeOutput;
  1648.                         }
  1649.  
  1650.                     Token = GetNextToken(Scanner);
  1651.                     if (Token == NIL)
  1652.                         {
  1653.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1654.                             return eBuildInstrOutOfMemory;
  1655.                         }
  1656.                     if (GetTokenType(Token) != eTokenKeyword)
  1657.                         {
  1658.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1659.                             return eBuildInstrExpectedBoolean;
  1660.                         }
  1661.                     switch (GetTokenKeywordTag(Token))
  1662.                         {
  1663.                             default:
  1664.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1665.                                 return eBuildInstrExpectedBoolean;
  1666.                             case eKeywordTrue:
  1667.                                 PutOscillatorIncludeInOutputFlag(Oscillator,True);
  1668.                                 break;
  1669.                             case eKeywordFalse:
  1670.                                 PutOscillatorIncludeInOutputFlag(Oscillator,False);
  1671.                                 break;
  1672.                         }
  1673.  
  1674.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_MAKEOUTPUT;
  1675.                     break;
  1676.  
  1677.                 case eKeywordLoudnessenvelope:
  1678.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_LOUDNESSENVELOPE) != 0)
  1679.                         {
  1680.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1681.                             return eBuildInstrMultipleOscLoudnessEnvelope;
  1682.                         }
  1683.  
  1684.                     /* open paren */
  1685.                     Token = GetNextToken(Scanner);
  1686.                     if (Token == NIL)
  1687.                         {
  1688.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1689.                             return eBuildInstrOutOfMemory;
  1690.                         }
  1691.                     if (GetTokenType(Token) != eTokenOpenParen)
  1692.                         {
  1693.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1694.                             return eBuildInstrExpectedOpenParen;
  1695.                         }
  1696.  
  1697.                     Required = 0;
  1698.                     Error = ParseEnvelopeDefinition(OscillatorGetLoudnessEnvelope(Oscillator),
  1699.                         Scanner,ErrorLine,&Required,0);
  1700.                     if (Error != eBuildInstrNoError)
  1701.                         {
  1702.                             return Error;
  1703.                         }
  1704.                     if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  1705.                         {
  1706.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1707.                             return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1708.                         }
  1709.  
  1710.                     /* close paren */
  1711.                     Token = GetNextToken(Scanner);
  1712.                     if (Token == NIL)
  1713.                         {
  1714.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1715.                             return eBuildInstrOutOfMemory;
  1716.                         }
  1717.                     if (GetTokenType(Token) != eTokenCloseParen)
  1718.                         {
  1719.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1720.                             return eBuildInstrExpectedCloseParen;
  1721.                         }
  1722.  
  1723.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_LOUDNESSENVELOPE;
  1724.                     *RequiredDefinitions |= OSCILLATORDEFINITION_REQUIRED_LOUDNESSENVELOPE;
  1725.                     break;
  1726.  
  1727.                 case eKeywordLoudnesslfo:
  1728.                     {
  1729.                         LFOSpecRec*                    LFO;
  1730.  
  1731.                         /* create the LFO */
  1732.                         LFO = NewLFOSpecifier();
  1733.                         if (LFO == NIL)
  1734.                             {
  1735.                              LoudnessLFOAllocFailurePoint1:
  1736.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1737.                                 return eBuildInstrOutOfMemory;
  1738.                             }
  1739.                         if (!LFOListSpecAppendNewEntry(OscillatorGetLoudnessLFOList(Oscillator),LFO))
  1740.                             {
  1741.                              LoudnessLFOAllocFailurePoint2:
  1742.                                 DisposeLFOSpecifier(LFO);
  1743.                                 goto LoudnessLFOAllocFailurePoint1;
  1744.                             }
  1745.  
  1746.                         /* open paren */
  1747.                         Token = GetNextToken(Scanner);
  1748.                         if (Token == NIL)
  1749.                             {
  1750.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1751.                                 return eBuildInstrOutOfMemory;
  1752.                             }
  1753.                         if (GetTokenType(Token) != eTokenOpenParen)
  1754.                             {
  1755.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1756.                                 return eBuildInstrExpectedOpenParen;
  1757.                             }
  1758.  
  1759.                         Required = 0;
  1760.                         Error = ParseLfoDefinition(LFO,Scanner,ErrorLine,&Required,0,
  1761.                             WaveTableList,AlgoWaveTableList);
  1762.                         if (Error != eBuildInstrNoError)
  1763.                             {
  1764.                                 return Error;
  1765.                             }
  1766.                         if (Required != LFODEFINITION_REQUIREDMASK)
  1767.                             {
  1768.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1769.                                 return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1770.                             }
  1771.  
  1772.                         /* close paren */
  1773.                         Token = GetNextToken(Scanner);
  1774.                         if (Token == NIL)
  1775.                             {
  1776.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1777.                                 return eBuildInstrOutOfMemory;
  1778.                             }
  1779.                         if (GetTokenType(Token) != eTokenCloseParen)
  1780.                             {
  1781.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1782.                                 return eBuildInstrExpectedCloseParen;
  1783.                             }
  1784.                     }
  1785.                     break;
  1786.  
  1787.                 case eKeywordIndexenvelope:
  1788.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_INDEXENVELOPE) != 0)
  1789.                         {
  1790.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1791.                             return eBuildInstrMultipleOscIndexEnvelope;
  1792.                         }
  1793.  
  1794.                     /* open paren */
  1795.                     Token = GetNextToken(Scanner);
  1796.                     if (Token == NIL)
  1797.                         {
  1798.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1799.                             return eBuildInstrOutOfMemory;
  1800.                         }
  1801.                     if (GetTokenType(Token) != eTokenOpenParen)
  1802.                         {
  1803.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1804.                             return eBuildInstrExpectedOpenParen;
  1805.                         }
  1806.  
  1807.                     Required = 0;
  1808.                     Error = ParseEnvelopeDefinition(OscillatorGetExcitationEnvelope(Oscillator),
  1809.                         Scanner,ErrorLine,&Required,0);
  1810.                     if (Error != eBuildInstrNoError)
  1811.                         {
  1812.                             return Error;
  1813.                         }
  1814.                     if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  1815.                         {
  1816.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1817.                             return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1818.                         }
  1819.  
  1820.                     /* close paren */
  1821.                     Token = GetNextToken(Scanner);
  1822.                     if (Token == NIL)
  1823.                         {
  1824.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1825.                             return eBuildInstrOutOfMemory;
  1826.                         }
  1827.                     if (GetTokenType(Token) != eTokenCloseParen)
  1828.                         {
  1829.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1830.                             return eBuildInstrExpectedCloseParen;
  1831.                         }
  1832.  
  1833.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_INDEXENVELOPE;
  1834.                     break;
  1835.  
  1836.                 case eKeywordIndexlfo:
  1837.                     {
  1838.                         LFOSpecRec*                    LFO;
  1839.  
  1840.                         /* create the LFO */
  1841.                         LFO = NewLFOSpecifier();
  1842.                         if (LFO == NIL)
  1843.                             {
  1844.                              IndexLFOAllocFailurePoint1:
  1845.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1846.                                 return eBuildInstrOutOfMemory;
  1847.                             }
  1848.                         if (!LFOListSpecAppendNewEntry(OscillatorGetExcitationLFOList(Oscillator),LFO))
  1849.                             {
  1850.                              IndexLFOAllocFailurePoint2:
  1851.                                 DisposeLFOSpecifier(LFO);
  1852.                                 goto IndexLFOAllocFailurePoint1;
  1853.                             }
  1854.  
  1855.                         /* open paren */
  1856.                         Token = GetNextToken(Scanner);
  1857.                         if (Token == NIL)
  1858.                             {
  1859.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1860.                                 return eBuildInstrOutOfMemory;
  1861.                             }
  1862.                         if (GetTokenType(Token) != eTokenOpenParen)
  1863.                             {
  1864.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1865.                                 return eBuildInstrExpectedOpenParen;
  1866.                             }
  1867.  
  1868.                         Required = 0;
  1869.                         Error = ParseLfoDefinition(LFO,Scanner,ErrorLine,&Required,0,
  1870.                             WaveTableList,AlgoWaveTableList);
  1871.                         if (Error != eBuildInstrNoError)
  1872.                             {
  1873.                                 return Error;
  1874.                             }
  1875.                         if (Required != LFODEFINITION_REQUIREDMASK)
  1876.                             {
  1877.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1878.                                 return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  1879.                             }
  1880.  
  1881.                         /* close paren */
  1882.                         Token = GetNextToken(Scanner);
  1883.                         if (Token == NIL)
  1884.                             {
  1885.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1886.                                 return eBuildInstrOutOfMemory;
  1887.                             }
  1888.                         if (GetTokenType(Token) != eTokenCloseParen)
  1889.                             {
  1890.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1891.                                 return eBuildInstrExpectedCloseParen;
  1892.                             }
  1893.                     }
  1894.                     break;
  1895.  
  1896.                 case eKeywordStereobias:
  1897.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_STEREOBIAS) != 0)
  1898.                         {
  1899.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1900.                             return eBuildInstrMultipleOscStereoBias;
  1901.                         }
  1902.  
  1903.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1904.                     if (Error != eBuildInstrNoError)
  1905.                         {
  1906.                             return Error;
  1907.                         }
  1908.                     OscillatorPutStereoBias(Oscillator,Number);
  1909.  
  1910.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_STEREOBIAS;
  1911.                     break;
  1912.  
  1913.                 case eKeywordDisplacement:
  1914.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_TIMEDISPLACEMENT) != 0)
  1915.                         {
  1916.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1917.                             return eBuildInstrMultipleOscDisplacement;
  1918.                         }
  1919.  
  1920.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1921.                     if (Error != eBuildInstrNoError)
  1922.                         {
  1923.                             return Error;
  1924.                         }
  1925.                     OscillatorPutTimeDisplacement(Oscillator,Number);
  1926.  
  1927.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_TIMEDISPLACEMENT;
  1928.                     break;
  1929.  
  1930.                 case eKeywordSurroundbias:
  1931.                     if ((*OnceOnlyDefinitions & OSCILLATORDEFINITION_ONCEONLY_SURROUNDBIAS) != 0)
  1932.                         {
  1933.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  1934.                             return eBuildInstrMultipleOscSurroundBias;
  1935.                         }
  1936.  
  1937.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  1938.                     if (Error != eBuildInstrNoError)
  1939.                         {
  1940.                             return Error;
  1941.                         }
  1942.                     OscillatorPutSurroundBias(Oscillator,Number);
  1943.  
  1944.                     *OnceOnlyDefinitions |= OSCILLATORDEFINITION_ONCEONLY_SURROUNDBIAS;
  1945.                     break;
  1946.             }
  1947.  
  1948.         return eBuildInstrNoError;
  1949.     }
  1950.  
  1951.  
  1952.  
  1953.  
  1954. /*   42:   <envelope_definition>   ::= <envelope_elem> ; <envelope_definition> */
  1955. /*   43:                           ::=  */
  1956. /* FIRST SET: */
  1957. /*  <envelope_definition>   : {totalscaling, points, <envelope_elem>} */
  1958. /* FOLLOW SET: */
  1959. /*  <envelope_definition>   : {)} */
  1960. static BuildInstrErrors            ParseEnvelopeDefinition(EnvelopeRec* Envelope,
  1961.                                                             ScannerRec* Scanner, long* ErrorLine,
  1962.                                                             unsigned long* RequiredDefinitions,
  1963.                                                             unsigned long OnceOnlyDefinitions)
  1964.     {
  1965.         TokenRec*                                    Token;
  1966.         BuildInstrErrors                    Error;
  1967.  
  1968.         CheckPtrExistence(Envelope);
  1969.         CheckPtrExistence(Scanner);
  1970.  
  1971.         Token = GetNextToken(Scanner);
  1972.         if (Token == NIL)
  1973.             {
  1974.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  1975.                 return eBuildInstrOutOfMemory;
  1976.             }
  1977.  
  1978.         if (GetTokenType(Token) == eTokenCloseParen)
  1979.             {
  1980.                 UngetToken(Scanner,Token);
  1981.                 return eBuildInstrNoError;
  1982.             }
  1983.          else
  1984.             {
  1985.                 UngetToken(Scanner,Token);
  1986.  
  1987.                 Error = ParseEnvelopeElem(Envelope,Scanner,ErrorLine,RequiredDefinitions,
  1988.                     &OnceOnlyDefinitions);
  1989.                 if (Error != eBuildInstrNoError)
  1990.                     {
  1991.                         return Error;
  1992.                     }
  1993.  
  1994.                 /* get semicolon */
  1995.                 Token = GetNextToken(Scanner);
  1996.                 if (Token == NIL)
  1997.                     {
  1998.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  1999.                         return eBuildInstrOutOfMemory;
  2000.                     }
  2001.                 if (GetTokenType(Token) != eTokenSemicolon)
  2002.                     {
  2003.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2004.                         return eBuildInstrExpectedSemicolon;
  2005.                     }
  2006.  
  2007.                 return ParseEnvelopeDefinition(Envelope,Scanner,ErrorLine,RequiredDefinitions,
  2008.                     OnceOnlyDefinitions);
  2009.             }
  2010.  
  2011.         EXECUTE(PRERR(ForceAbort,"ParseEnvelopeDefinition:  control reached end of function"));
  2012.     }
  2013.  
  2014.  
  2015.  
  2016.  
  2017. /*   68:   <samplelist_definition> ::= <samplelist_elem> ; */
  2018. /*       <samplelist_definition> */
  2019. /*   69:                           ::=  */
  2020. /* FIRST SET: */
  2021. /*  <samplelist_definition> : {<identifiertoken>, <stringtoken>, */
  2022. /*       <identifier>, <samplelist_elem>} */
  2023. /* FOLLOW SET: */
  2024. /*  <samplelist_definition> : {)} */
  2025. static BuildInstrErrors            ParseSamplelistDefinition(SampleSelectorRec* SampleList,
  2026.                                                             ScannerRec* Scanner, long* ErrorLine)
  2027.     {
  2028.         TokenRec*                                    Token;
  2029.         BuildInstrErrors                    Error;
  2030.  
  2031.         CheckPtrExistence(SampleList);
  2032.         CheckPtrExistence(Scanner);
  2033.  
  2034.         Token = GetNextToken(Scanner);
  2035.         if (Token == NIL)
  2036.             {
  2037.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2038.                 return eBuildInstrOutOfMemory;
  2039.             }
  2040.  
  2041.         if (GetTokenType(Token) == eTokenCloseParen)
  2042.             {
  2043.                 UngetToken(Scanner,Token);
  2044.                 return eBuildInstrNoError;
  2045.             }
  2046.          else
  2047.             {
  2048.                 UngetToken(Scanner,Token);
  2049.  
  2050.                 Error = ParseSamplelistElem(SampleList,Scanner,ErrorLine);
  2051.                 if (Error != eBuildInstrNoError)
  2052.                     {
  2053.                         return Error;
  2054.                     }
  2055.  
  2056.                 /* get semicolon */
  2057.                 Token = GetNextToken(Scanner);
  2058.                 if (Token == NIL)
  2059.                     {
  2060.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2061.                         return eBuildInstrOutOfMemory;
  2062.                     }
  2063.                 if (GetTokenType(Token) != eTokenSemicolon)
  2064.                     {
  2065.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2066.                         return eBuildInstrExpectedSemicolon;
  2067.                     }
  2068.  
  2069.                 return ParseSamplelistDefinition(SampleList,Scanner,ErrorLine);
  2070.             }
  2071.  
  2072.         EXECUTE(PRERR(ForceAbort,"ParseSamplelistDefinition:  control reached end of function"));
  2073.     }
  2074.  
  2075.  
  2076.  
  2077.  
  2078. /*   71:   <modulator_list>        ::= <modulator_elem> ; <modulator_list> */
  2079. /*   72:                           ::=  */
  2080. /* FIRST SET: */
  2081. /*  <modulator_list>        : {source, <modulator_elem>} */
  2082. /* FOLLOW SET: */
  2083. /*  <modulator_list>        : {)} */
  2084. static BuildInstrErrors            ParseModulatorList(ModulationSpecRec* ModulatorList,
  2085.                                                             ScannerRec* Scanner, long* ErrorLine,
  2086.                                                             struct WaveTableListRec* WaveTableList,
  2087.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  2088.     {
  2089.         TokenRec*                                    Token;
  2090.         BuildInstrErrors                    Error;
  2091.  
  2092.         CheckPtrExistence(ModulatorList);
  2093.         CheckPtrExistence(Scanner);
  2094.  
  2095.         Token = GetNextToken(Scanner);
  2096.         if (Token == NIL)
  2097.             {
  2098.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2099.                 return eBuildInstrOutOfMemory;
  2100.             }
  2101.  
  2102.         if (GetTokenType(Token) == eTokenCloseParen)
  2103.             {
  2104.                 UngetToken(Scanner,Token);
  2105.                 return eBuildInstrNoError;
  2106.             }
  2107.          else
  2108.             {
  2109.                 UngetToken(Scanner,Token);
  2110.  
  2111.                 Error = ParseModulatorElem(ModulatorList,Scanner,ErrorLine,WaveTableList,
  2112.                     AlgoWaveTableList);
  2113.                 if (Error != eBuildInstrNoError)
  2114.                     {
  2115.                         return Error;
  2116.                     }
  2117.  
  2118.                 /* get semicolon */
  2119.                 Token = GetNextToken(Scanner);
  2120.                 if (Token == NIL)
  2121.                     {
  2122.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2123.                         return eBuildInstrOutOfMemory;
  2124.                     }
  2125.                 if (GetTokenType(Token) != eTokenSemicolon)
  2126.                     {
  2127.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2128.                         return eBuildInstrExpectedSemicolon;
  2129.                     }
  2130.  
  2131.                 return ParseModulatorList(ModulatorList,Scanner,ErrorLine,WaveTableList,
  2132.                     AlgoWaveTableList);
  2133.             }
  2134.  
  2135.         EXECUTE(PRERR(ForceAbort,"ParseModulatorList:  control reached end of function"));
  2136.     }
  2137.  
  2138.  
  2139.  
  2140.  
  2141. /*   45:   <envelope_elem>         ::= totalscaling <number> */
  2142. /*   49:                           ::= points ( <env_point_list> ) */
  2143. /* FIRST SET: */
  2144. /*  <envelope_elem>         : {totalscaling, points} */
  2145. /* FOLLOW SET: */
  2146. /*  <envelope_elem>         : {;} */
  2147. static BuildInstrErrors            ParseEnvelopeElem(EnvelopeRec* Envelope,
  2148.                                                             ScannerRec* Scanner, long *ErrorLine,
  2149.                                                             unsigned long* RequiredDefinitions,
  2150.                                                             unsigned long* OnceOnlyDefinitions)
  2151.     {
  2152.         TokenRec*                                    Token;
  2153.         BuildInstrErrors                    Error;
  2154.         double                                        Number;
  2155.  
  2156.         CheckPtrExistence(Envelope);
  2157.         CheckPtrExistence(Scanner);
  2158.  
  2159.         Token = GetNextToken(Scanner);
  2160.         if (Token == NIL)
  2161.             {
  2162.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2163.                 return eBuildInstrOutOfMemory;
  2164.             }
  2165.         if (GetTokenType(Token) != eTokenKeyword)
  2166.             {
  2167.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2168.                 return eBuildInstrExpectedEnvelopeMember;
  2169.             }
  2170.  
  2171.         switch (GetTokenKeywordTag(Token))
  2172.             {
  2173.                 default:
  2174.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  2175.                     return eBuildInstrExpectedEnvelopeMember;
  2176.  
  2177.                 case eKeywordTotalscaling:
  2178.                     if ((*OnceOnlyDefinitions & ENVELOPEDEFINITION_ONCEONLY_TOTALSCALING) != 0)
  2179.                         {
  2180.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2181.                             return eBuildInstrMultipleEnvTotalScaling;
  2182.                         }
  2183.  
  2184.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  2185.                     if (Error != eBuildInstrNoError)
  2186.                         {
  2187.                             return Error;
  2188.                         }
  2189.                     EnvelopeSetOverallAmplitude(Envelope,Number);
  2190.  
  2191.                     *OnceOnlyDefinitions |= ENVELOPEDEFINITION_ONCEONLY_TOTALSCALING;
  2192.                     break;
  2193.  
  2194.                 case eKeywordPoints:
  2195.                     if ((*OnceOnlyDefinitions & ENVELOPEDEFINITION_ONCEONLY_POINTS) != 0)
  2196.                         {
  2197.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2198.                             return eBuildInstrMultipleEnvPoints;
  2199.                         }
  2200.  
  2201.                     /* open paren */
  2202.                     Token = GetNextToken(Scanner);
  2203.                     if (Token == NIL)
  2204.                         {
  2205.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2206.                             return eBuildInstrOutOfMemory;
  2207.                         }
  2208.                     if (GetTokenType(Token) != eTokenOpenParen)
  2209.                         {
  2210.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2211.                             return eBuildInstrExpectedOpenParen;
  2212.                         }
  2213.  
  2214.                     Error = ParseEnvPointList(Envelope,Scanner,ErrorLine);
  2215.                     if (Error != eBuildInstrNoError)
  2216.                         {
  2217.                             return Error;
  2218.                         }
  2219.  
  2220.                     /* close paren */
  2221.                     Token = GetNextToken(Scanner);
  2222.                     if (Token == NIL)
  2223.                         {
  2224.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2225.                             return eBuildInstrOutOfMemory;
  2226.                         }
  2227.                     if (GetTokenType(Token) != eTokenCloseParen)
  2228.                         {
  2229.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2230.                             return eBuildInstrExpectedCloseParen;
  2231.                         }
  2232.  
  2233.                     *OnceOnlyDefinitions |= ENVELOPEDEFINITION_ONCEONLY_POINTS;
  2234.                     break;
  2235.             }
  2236.  
  2237.         return eBuildInstrNoError;
  2238.     }
  2239.  
  2240.  
  2241.  
  2242.  
  2243. /*   70:   <samplelist_elem>       ::= <identifier> <number> */
  2244. /* FIRST SET: */
  2245. /*  <samplelist_elem>       : {<identifiertoken>, <stringtoken>, <identifier>} */
  2246. /* FOLLOW SET: */
  2247. /*  <samplelist_elem>       : {;} */
  2248. static BuildInstrErrors            ParseSamplelistElem(SampleSelectorRec* SampleList,
  2249.                                                             ScannerRec* Scanner, long* ErrorLine)
  2250.     {
  2251.         TokenRec*                                    Token;
  2252.         BuildInstrErrors                    Error;
  2253.         char*                                            SampleName;
  2254.         double                                        Number;
  2255.  
  2256.         CheckPtrExistence(SampleList);
  2257.         CheckPtrExistence(Scanner);
  2258.  
  2259.         Error = ParseIdentifier(Scanner,ErrorLine,&SampleName);
  2260.         if (Error != eBuildInstrNoError)
  2261.             {
  2262.                 return Error;
  2263.             }
  2264.  
  2265.         Error = ParseNumber(Scanner,ErrorLine,&Number);
  2266.         if (Error != eBuildInstrNoError)
  2267.             {
  2268.                 ReleasePtr(SampleName);
  2269.                 return Error;
  2270.             }
  2271.  
  2272.         if (!AppendSampleSelector(SampleList,Number,SampleName))
  2273.             {
  2274.                 ReleasePtr(SampleName);
  2275.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2276.                 return eBuildInstrOutOfMemory;
  2277.             }
  2278.  
  2279.         return eBuildInstrNoError;
  2280.     }
  2281.  
  2282.  
  2283.  
  2284.  
  2285. /*   73:   <modulator_elem>        ::= source <identifier> scale <modulation_dynamic> */
  2286. /*       originadjust <modulation_dynamic> type <modulator_types> target <target_type> */
  2287. /* FIRST SET: */
  2288. /*  <modulator_elem>        : {source} */
  2289. /* FOLLOW SET: */
  2290. /*  <modulator_elem>        : {;} */
  2291. static BuildInstrErrors            ParseModulatorElem(ModulationSpecRec* ModulatorList,
  2292.                                                             ScannerRec* Scanner, long* ErrorLine,
  2293.                                                             struct WaveTableListRec* WaveTableList,
  2294.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  2295.     {
  2296.         TokenRec*                                    Token;
  2297.         BuildInstrErrors                    Error;
  2298.         char*                                            SourceOscillatorName;
  2299.         EnvelopeRec*                            ScalingFactorEnvelope;
  2300.         LFOListSpecRec*                        ScalingFactorLFOList;
  2301.         EnvelopeRec*                            OriginAdjustEnvelope;
  2302.         LFOListSpecRec*                        OriginAdjustLFOList;
  2303.         ModulationTypes                        Modulation;
  2304.         ModDestTypes                            Destination;
  2305.  
  2306.         CheckPtrExistence(ModulatorList);
  2307.         CheckPtrExistence(Scanner);
  2308.  
  2309.         Token = GetNextToken(Scanner);
  2310.         if (Token == NIL)
  2311.             {
  2312.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2313.                 Error = eBuildInstrOutOfMemory;
  2314.              FailurePoint1:
  2315.                 return Error;
  2316.             }
  2317.         if ((GetTokenType(Token) != eTokenKeyword)
  2318.             || (GetTokenKeywordTag(Token) != eKeywordSource))
  2319.             {
  2320.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2321.                 Error = eBuildInstrExpectedSource;
  2322.              FailurePoint2:
  2323.                 goto FailurePoint1;
  2324.             }
  2325.  
  2326.         Error = ParseIdentifier(Scanner,ErrorLine,&SourceOscillatorName);
  2327.         if (Error != eBuildInstrNoError)
  2328.             {
  2329.              FailurePoint3:
  2330.                 goto FailurePoint2;
  2331.             }
  2332.  
  2333.         Token = GetNextToken(Scanner);
  2334.         if (Token == NIL)
  2335.             {
  2336.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2337.                 Error = eBuildInstrOutOfMemory;
  2338.              FailurePoint4:
  2339.                 ReleasePtr(SourceOscillatorName);
  2340.                 goto FailurePoint3;
  2341.             }
  2342.         if ((GetTokenType(Token) != eTokenKeyword)
  2343.             || (GetTokenKeywordTag(Token) != eKeywordScale))
  2344.             {
  2345.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2346.                 Error = eBuildInstrExpectedScale;
  2347.              FailurePoint5:
  2348.                 goto FailurePoint4;
  2349.             }
  2350.  
  2351.         Error = ParseModulationDynamic(&ScalingFactorLFOList,&ScalingFactorEnvelope,
  2352.             Scanner,ErrorLine,WaveTableList,AlgoWaveTableList);
  2353.         if (Error != eBuildInstrNoError)
  2354.             {
  2355.              FailurePoint6:
  2356.                 goto FailurePoint5;
  2357.             }
  2358.  
  2359.         Token = GetNextToken(Scanner);
  2360.         if (Token == NIL)
  2361.             {
  2362.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2363.                 Error = eBuildInstrOutOfMemory;
  2364.              FailurePoint7:
  2365.                 DisposeEnvelope(ScalingFactorEnvelope);
  2366.                 DisposeLFOListSpecifier(ScalingFactorLFOList);
  2367.                 goto FailurePoint6;
  2368.             }
  2369.         if ((GetTokenType(Token) != eTokenKeyword)
  2370.             || (GetTokenKeywordTag(Token) != eKeywordOriginadjust))
  2371.             {
  2372.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2373.                 Error = eBuildInstrExpectedOriginadjust;
  2374.              FailurePoint8:
  2375.                 goto FailurePoint7;
  2376.             }
  2377.  
  2378.         Error = ParseModulationDynamic(&OriginAdjustLFOList,&OriginAdjustEnvelope,
  2379.             Scanner,ErrorLine,WaveTableList,AlgoWaveTableList);
  2380.         if (Error != eBuildInstrNoError)
  2381.             {
  2382.              FailurePoint9:
  2383.                 goto FailurePoint8;
  2384.             }
  2385.  
  2386.         Token = GetNextToken(Scanner);
  2387.         if (Token == NIL)
  2388.             {
  2389.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2390.                 Error = eBuildInstrOutOfMemory;
  2391.              FailurePoint10:
  2392.                 DisposeEnvelope(OriginAdjustEnvelope);
  2393.                 DisposeLFOListSpecifier(OriginAdjustLFOList);
  2394.                 goto FailurePoint9;
  2395.             }
  2396.         if ((GetTokenType(Token) != eTokenKeyword)
  2397.             || (GetTokenKeywordTag(Token) != eKeywordType))
  2398.             {
  2399.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2400.                 Error = eBuildInstrExpectedType;
  2401.              FailurePoint11:
  2402.                 goto FailurePoint10;
  2403.             }
  2404.  
  2405.         /*  74:   <modulator_types>       ::= additive */
  2406.         /*  75:                           ::= multiplicative */
  2407.         /*  XX:                           ::= inversemult */
  2408.         Token = GetNextToken(Scanner);
  2409.         if (Token == NIL)
  2410.             {
  2411.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2412.                 Error = eBuildInstrOutOfMemory;
  2413.              FailurePoint12:
  2414.                 goto FailurePoint11;
  2415.             }
  2416.         if (GetTokenType(Token) != eTokenKeyword)
  2417.             {
  2418.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2419.                 Error = eBuildInstrExpectedModulationTypeSpecifier;
  2420.              FailurePoint13:
  2421.                 goto FailurePoint12;
  2422.             }
  2423.         switch (GetTokenKeywordTag(Token))
  2424.             {
  2425.                 default:
  2426.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  2427.                     Error = eBuildInstrExpectedModulationTypeSpecifier;
  2428.                  FailurePoint14:
  2429.                     goto FailurePoint13;
  2430.                 case eKeywordAdditive:
  2431.                     Modulation = eModulationAdditive;
  2432.                     break;
  2433.                 case eKeywordMultiplicative:
  2434.                     Modulation = eModulationMultiplicative;
  2435.                     break;
  2436.             }
  2437.  
  2438.         Token = GetNextToken(Scanner);
  2439.         if (Token == NIL)
  2440.             {
  2441.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2442.                 Error = eBuildInstrOutOfMemory;
  2443.              FailurePoint15:
  2444.                 goto FailurePoint14;
  2445.             }
  2446.         if ((GetTokenType(Token) != eTokenKeyword)
  2447.             || (GetTokenKeywordTag(Token) != eKeywordTarget))
  2448.             {
  2449.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2450.                 Error = eBuildInstrExpectedTarget;
  2451.              FailurePoint16:
  2452.                 goto FailurePoint15;
  2453.             }
  2454.  
  2455.         /*  76:   <target_type>           ::= phasegen */
  2456.         /*  77:                           ::= output */
  2457.         Token = GetNextToken(Scanner);
  2458.         if (Token == NIL)
  2459.             {
  2460.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2461.                 Error = eBuildInstrOutOfMemory;
  2462.              FailurePoint17:
  2463.                 goto FailurePoint16;
  2464.             }
  2465.         if (GetTokenType(Token) != eTokenKeyword)
  2466.             {
  2467.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2468.                 Error = eBuildInstrExpectedModulationTargetSpecifier;
  2469.              FailurePoint18:
  2470.                 goto FailurePoint17;
  2471.             }
  2472.         switch (GetTokenKeywordTag(Token))
  2473.             {
  2474.                 default:
  2475.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  2476.                     Error = eBuildInstrExpectedModulationTargetSpecifier;
  2477.                  FailurePoint19:
  2478.                     goto FailurePoint18;
  2479.                 case eKeywordPhasegen:
  2480.                     Destination = eModulatePhaseGen;
  2481.                     break;
  2482.                 case eKeywordOutput:
  2483.                     Destination = eModulateOutput;
  2484.                     break;
  2485.             }
  2486.  
  2487.         if (!AppendModulationSpecEntry(ModulatorList,Modulation,Destination,
  2488.             ScalingFactorEnvelope,ScalingFactorLFOList,OriginAdjustEnvelope,
  2489.             OriginAdjustLFOList,SourceOscillatorName))
  2490.             {
  2491.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2492.                 Error = eBuildInstrOutOfMemory;
  2493.              FailurePoint20:
  2494.                 goto FailurePoint19;
  2495.             }
  2496.  
  2497.         return eBuildInstrNoError;
  2498.     }
  2499.  
  2500.  
  2501.  
  2502.  
  2503. /*   50:   <env_point_list>        ::= <env_point_elem> ; <env_point_list> */
  2504. /*   51:                           ::=  */
  2505. /* FIRST SET: */
  2506. /*  <env_point_list>        : {<integertoken>, <floattoken>, <number>, */
  2507. /*       <env_point_elem>} */
  2508. /* FOLLOW SET: */
  2509. /*  <env_point_list>        : {)} */
  2510. static BuildInstrErrors            ParseEnvPointList(EnvelopeRec* Envelope,
  2511.                                                             ScannerRec* Scanner, long *ErrorLine)
  2512.     {
  2513.         TokenRec*                                    Token;
  2514.         BuildInstrErrors                    Error;
  2515.  
  2516.         CheckPtrExistence(Envelope);
  2517.         CheckPtrExistence(Scanner);
  2518.  
  2519.         Token = GetNextToken(Scanner);
  2520.         if (Token == NIL)
  2521.             {
  2522.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2523.                 return eBuildInstrOutOfMemory;
  2524.             }
  2525.  
  2526.         if (GetTokenType(Token) == eTokenCloseParen)
  2527.             {
  2528.                 UngetToken(Scanner,Token);
  2529.                 return eBuildInstrNoError;
  2530.             }
  2531.          else
  2532.             {
  2533.                 UngetToken(Scanner,Token);
  2534.  
  2535.                 Error = ParseEnvPointElem(Envelope,Scanner,ErrorLine);
  2536.                 if (Error != eBuildInstrNoError)
  2537.                     {
  2538.                         return Error;
  2539.                     }
  2540.  
  2541.                 /* get semicolon */
  2542.                 Token = GetNextToken(Scanner);
  2543.                 if (Token == NIL)
  2544.                     {
  2545.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2546.                         return eBuildInstrOutOfMemory;
  2547.                     }
  2548.                 if (GetTokenType(Token) != eTokenSemicolon)
  2549.                     {
  2550.                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2551.                         return eBuildInstrExpectedSemicolon;
  2552.                     }
  2553.  
  2554.                 return ParseEnvPointList(Envelope,Scanner,ErrorLine);
  2555.             }
  2556.  
  2557.         EXECUTE(PRERR(ForceAbort,"ParseEnvPointList:  control reached end of function"));
  2558.     }
  2559.  
  2560.  
  2561.  
  2562.  
  2563. /*   52:   <env_point_elem>        ::= delay <number> level <number> <env_attributes> */
  2564. /*   XX:                           ::= origin */
  2565. /* FIRST SET: */
  2566. /*  <env_point_elem>        : {delay} */
  2567. /* FOLLOW SET: */
  2568. /*  <env_point_elem>        : {<integertoken>, <floattoken>, ), <number>, */
  2569. /*       <env_point_list>, <env_point_elem>} */
  2570. static BuildInstrErrors            ParseEnvPointElem(EnvelopeRec* Envelope,
  2571.                                                             ScannerRec* Scanner, long *ErrorLine)
  2572.     {
  2573.         TokenRec*                                    Token;
  2574.         BuildInstrErrors                    Error;
  2575.         double                                        Delay;
  2576.         double                                        Level;
  2577.  
  2578.         CheckPtrExistence(Envelope);
  2579.         CheckPtrExistence(Scanner);
  2580.  
  2581.         Token = GetNextToken(Scanner);
  2582.         if (Token == NIL)
  2583.             {
  2584.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2585.                 return eBuildInstrOutOfMemory;
  2586.             }
  2587.         if (GetTokenType(Token) != eTokenKeyword)
  2588.             {
  2589.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2590.                 return eBuildInstrExpectedDelayOrOrigin;
  2591.             }
  2592.  
  2593.         switch (GetTokenKeywordTag(Token))
  2594.             {
  2595.                 default:
  2596.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  2597.                     return eBuildInstrExpectedDelayOrOrigin;
  2598.  
  2599.                 case eKeywordDelay:
  2600.                     Error = ParseNumber(Scanner,ErrorLine,&Delay);
  2601.                     if (Error != eBuildInstrNoError)
  2602.                         {
  2603.                             return Error;
  2604.                         }
  2605.  
  2606.                     Token = GetNextToken(Scanner);
  2607.                     if (Token == NIL)
  2608.                         {
  2609.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2610.                             return eBuildInstrOutOfMemory;
  2611.                         }
  2612.                     if ((GetTokenType(Token) != eTokenKeyword)
  2613.                         || (GetTokenKeywordTag(Token) != eKeywordLevel))
  2614.                         {
  2615.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2616.                             return eBuildInstrExpectedLevel;
  2617.                         }
  2618.  
  2619.                     Error = ParseNumber(Scanner,ErrorLine,&Level);
  2620.                     if (Error != eBuildInstrNoError)
  2621.                         {
  2622.                             return Error;
  2623.                         }
  2624.  
  2625.                     if (!EnvelopeInsertPhase(Envelope,GetEnvelopeNumFrames(Envelope)))
  2626.                         {
  2627.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2628.                             return eBuildInstrOutOfMemory;
  2629.                         }
  2630.                     EnvelopeSetPhaseDuration(Envelope,GetEnvelopeNumFrames(Envelope) - 1,Delay);
  2631.                     EnvelopeSetPhaseFinalValue(Envelope,GetEnvelopeNumFrames(Envelope) - 1,Level);
  2632.  
  2633.                     return ParseEnvAttributes(Envelope,Scanner,ErrorLine,0);
  2634.  
  2635.                 case eKeywordOrigin:
  2636.                     EnvelopeSetOrigin(Envelope,GetEnvelopeNumFrames(Envelope));
  2637.                     return eBuildInstrNoError;
  2638.             }
  2639.         EXECUTE(PRERR(ForceAbort,"ParseEnvPointElem:  Control reached end of function"));
  2640.     }
  2641.  
  2642.  
  2643.  
  2644.  
  2645. /*   50:   <env_attributes>        ::= <env_one_attribute> <env_attributes> */
  2646. /*   51:                           ::=  */
  2647. /* FIRST SET: */
  2648. /*  <env_attributes>        : {exponential, linear, sustainpoint, */
  2649. /*       ampaccent1, ampaccent2, ampaccent3, ampaccent4, ampfreq, rateaccent1, */
  2650. /*       rateaccent2, rateaccent3, rateaccent4, ratefreq, <env_one_attribute>} */
  2651. /* FOLLOW SET: */
  2652. /*  <env_attributes>        : {;} */
  2653. static BuildInstrErrors            ParseEnvAttributes(EnvelopeRec* Envelope,
  2654.                                                             ScannerRec* Scanner, long *ErrorLine,
  2655.                                                             unsigned long OnceOnly)
  2656.     {
  2657.         TokenRec*                                    Token;
  2658.         BuildInstrErrors                    Error;
  2659.  
  2660.         CheckPtrExistence(Envelope);
  2661.         CheckPtrExistence(Scanner);
  2662.  
  2663.         Token = GetNextToken(Scanner);
  2664.         if (Token == NIL)
  2665.             {
  2666.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2667.                 return eBuildInstrOutOfMemory;
  2668.             }
  2669.  
  2670.         if (GetTokenType(Token) == eTokenSemicolon)
  2671.             {
  2672.                 UngetToken(Scanner,Token);
  2673.                 return eBuildInstrNoError;
  2674.             }
  2675.          else
  2676.             {
  2677.                 UngetToken(Scanner,Token);
  2678.  
  2679.                 Error = ParseEnvOneAttribute(Envelope,Scanner,ErrorLine,&OnceOnly);
  2680.                 if (Error != eBuildInstrNoError)
  2681.                     {
  2682.                         return Error;
  2683.                     }
  2684.  
  2685.                 return ParseEnvAttributes(Envelope,Scanner,ErrorLine,OnceOnly);
  2686.             }
  2687.  
  2688.         EXECUTE(PRERR(ForceAbort,"ParseEnvAttributes:  control reached end of function"));
  2689.     }
  2690.  
  2691.  
  2692.  
  2693.  
  2694. /*   52:   <env_one_attribute>     ::= sustainpoint <integertoken> */
  2695. /*   53:                           ::= ampaccent1 <number> */
  2696. /*   54:                           ::= ampaccent2 <number> */
  2697. /*   55:                           ::= ampaccent3 <number> */
  2698. /*   56:                           ::= ampaccent4 <number> */
  2699. /*   57:                           ::= ampfreq <number> <number> */
  2700. /*   58:                           ::= rateaccent1 <number> */
  2701. /*   59:                           ::= rateaccent2 <number> */
  2702. /*   60:                           ::= rateaccent3 <number> */
  2703. /*   61:                           ::= rateaccent4 <number> */
  2704. /*   62:                           ::= ratefreq <number> <number> */
  2705. /*   63:                           ::= exponential */
  2706. /*   64:                           ::= linear */
  2707. /* FIRST SET: */
  2708. /*  <env_one_attribute>     : {exponential, linear, sustainpoint, */
  2709. /*       ampaccent1, ampaccent2, ampaccent3, ampaccent4, ampfreq, */
  2710. /*       rateaccent1, rateaccent2, rateaccent3, rateaccent4, ratefreq} */
  2711. /* FOLLOW SET: */
  2712. /*  <env_one_attribute>     : {;, exponential, linear, */
  2713. /*       sustainpoint, ampaccent1, ampaccent2, ampaccent3, ampaccent4, */
  2714. /*       ampfreq, rateaccent1, rateaccent2, rateaccent3, rateaccent4, */
  2715. /*       ratefreq, <env_attributes>, <env_one_attribute>} */
  2716. static BuildInstrErrors            ParseEnvOneAttribute(EnvelopeRec* Envelope,
  2717.                                                             ScannerRec* Scanner, long *ErrorLine,
  2718.                                                             unsigned long* OnceOnlyDefinitions)
  2719.     {
  2720.         TokenRec*                                    Token;
  2721.         BuildInstrErrors                    Error;
  2722.         double                                        Number;
  2723.  
  2724.         CheckPtrExistence(Envelope);
  2725.         CheckPtrExistence(Scanner);
  2726.  
  2727.         Token = GetNextToken(Scanner);
  2728.         if (Token == NIL)
  2729.             {
  2730.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2731.                 return eBuildInstrNoError;
  2732.             }
  2733.         if (GetTokenType(Token) != eTokenKeyword)
  2734.             {
  2735.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2736.                 return eBuildInstrExpectedEnvPointMember;
  2737.             }
  2738.  
  2739.         switch (GetTokenKeywordTag(Token))
  2740.             {
  2741.                 default:
  2742.                     *ErrorLine = GetCurrentLineNumber(Scanner);
  2743.                     return eBuildInstrExpectedEnvPointMember;
  2744.  
  2745.                 case eKeywordSustainpoint:
  2746.                     Token = GetNextToken(Scanner);
  2747.                     if (Token == NIL)
  2748.                         {
  2749.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2750.                             return eBuildInstrNoError;
  2751.                         }
  2752.                     if (GetTokenType(Token) != eTokenInteger)
  2753.                         {
  2754.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2755.                             return eBuildInstrExpectedInteger;
  2756.                         }
  2757.                     switch (GetTokenIntegerValue(Token))
  2758.                         {
  2759.                             default:
  2760.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2761.                                 return eBuildInstrExpectedIntBetween1And3;
  2762.                             case 1:
  2763.                                 if (GetEnvelopeReleasePoint1(Envelope) != -1)
  2764.                                     {
  2765.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2766.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2767.                                     }
  2768.                                 EnvelopeSetReleasePoint1(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2769.                                     eEnvelopeSustainPointSkip);
  2770.                                 break;
  2771.                             case 2:
  2772.                                 if (GetEnvelopeReleasePoint2(Envelope) != -1)
  2773.                                     {
  2774.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2775.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2776.                                     }
  2777.                                 EnvelopeSetReleasePoint2(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2778.                                     eEnvelopeSustainPointSkip);
  2779.                                 break;
  2780.                             case 3:
  2781.                                 if (GetEnvelopeReleasePoint3(Envelope) != -1)
  2782.                                     {
  2783.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2784.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2785.                                     }
  2786.                                 EnvelopeSetReleasePoint3(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2787.                                     eEnvelopeSustainPointSkip);
  2788.                                 break;
  2789.                         }
  2790.                     break;
  2791.  
  2792.                 case eKeywordReleasepoint:
  2793.                     Token = GetNextToken(Scanner);
  2794.                     if (Token == NIL)
  2795.                         {
  2796.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2797.                             return eBuildInstrNoError;
  2798.                         }
  2799.                     if (GetTokenType(Token) != eTokenInteger)
  2800.                         {
  2801.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2802.                             return eBuildInstrExpectedInteger;
  2803.                         }
  2804.                     switch (GetTokenIntegerValue(Token))
  2805.                         {
  2806.                             default:
  2807.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2808.                                 return eBuildInstrExpectedIntBetween1And3;
  2809.                             case 1:
  2810.                                 if (GetEnvelopeReleasePoint1(Envelope) != -1)
  2811.                                     {
  2812.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2813.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2814.                                     }
  2815.                                 EnvelopeSetReleasePoint1(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2816.                                     eEnvelopeReleasePointSkip);
  2817.                                 break;
  2818.                             case 2:
  2819.                                 if (GetEnvelopeReleasePoint2(Envelope) != -1)
  2820.                                     {
  2821.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2822.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2823.                                     }
  2824.                                 EnvelopeSetReleasePoint2(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2825.                                     eEnvelopeReleasePointSkip);
  2826.                                 break;
  2827.                             case 3:
  2828.                                 if (GetEnvelopeReleasePoint3(Envelope) != -1)
  2829.                                     {
  2830.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2831.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2832.                                     }
  2833.                                 EnvelopeSetReleasePoint3(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2834.                                     eEnvelopeReleasePointSkip);
  2835.                                 break;
  2836.                         }
  2837.                     break;
  2838.  
  2839.                 case eKeywordSustainpointnoskip:
  2840.                     Token = GetNextToken(Scanner);
  2841.                     if (Token == NIL)
  2842.                         {
  2843.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2844.                             return eBuildInstrNoError;
  2845.                         }
  2846.                     if (GetTokenType(Token) != eTokenInteger)
  2847.                         {
  2848.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2849.                             return eBuildInstrExpectedInteger;
  2850.                         }
  2851.                     switch (GetTokenIntegerValue(Token))
  2852.                         {
  2853.                             default:
  2854.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2855.                                 return eBuildInstrExpectedIntBetween1And3;
  2856.                             case 1:
  2857.                                 if (GetEnvelopeReleasePoint1(Envelope) != -1)
  2858.                                     {
  2859.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2860.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2861.                                     }
  2862.                                 EnvelopeSetReleasePoint1(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2863.                                     eEnvelopeSustainPointNoSkip);
  2864.                                 break;
  2865.                             case 2:
  2866.                                 if (GetEnvelopeReleasePoint2(Envelope) != -1)
  2867.                                     {
  2868.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2869.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2870.                                     }
  2871.                                 EnvelopeSetReleasePoint2(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2872.                                     eEnvelopeSustainPointNoSkip);
  2873.                                 break;
  2874.                             case 3:
  2875.                                 if (GetEnvelopeReleasePoint3(Envelope) != -1)
  2876.                                     {
  2877.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2878.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2879.                                     }
  2880.                                 EnvelopeSetReleasePoint3(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2881.                                     eEnvelopeSustainPointNoSkip);
  2882.                                 break;
  2883.                         }
  2884.                     break;
  2885.  
  2886.                 case eKeywordReleasepointnoskip:
  2887.                     Token = GetNextToken(Scanner);
  2888.                     if (Token == NIL)
  2889.                         {
  2890.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2891.                             return eBuildInstrNoError;
  2892.                         }
  2893.                     if (GetTokenType(Token) != eTokenInteger)
  2894.                         {
  2895.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2896.                             return eBuildInstrExpectedInteger;
  2897.                         }
  2898.                     switch (GetTokenIntegerValue(Token))
  2899.                         {
  2900.                             default:
  2901.                                 *ErrorLine = GetCurrentLineNumber(Scanner);
  2902.                                 return eBuildInstrExpectedIntBetween1And3;
  2903.                             case 1:
  2904.                                 if (GetEnvelopeReleasePoint1(Envelope) != -1)
  2905.                                     {
  2906.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2907.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2908.                                     }
  2909.                                 EnvelopeSetReleasePoint1(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2910.                                     eEnvelopeReleasePointNoSkip);
  2911.                                 break;
  2912.                             case 2:
  2913.                                 if (GetEnvelopeReleasePoint2(Envelope) != -1)
  2914.                                     {
  2915.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2916.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2917.                                     }
  2918.                                 EnvelopeSetReleasePoint2(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2919.                                     eEnvelopeReleasePointNoSkip);
  2920.                                 break;
  2921.                             case 3:
  2922.                                 if (GetEnvelopeReleasePoint3(Envelope) != -1)
  2923.                                     {
  2924.                                         *ErrorLine = GetCurrentLineNumber(Scanner);
  2925.                                         return eBuildInstrEnvSustainPointAlreadyDefined;
  2926.                                     }
  2927.                                 EnvelopeSetReleasePoint3(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  2928.                                     eEnvelopeReleasePointNoSkip);
  2929.                                 break;
  2930.                         }
  2931.                     break;
  2932.  
  2933.                 case eKeywordAmpaccent1:
  2934.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPACCENT1) != 0)
  2935.                         {
  2936.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2937.                             return eBuildInstrMultipleEnvPointAmpAccent1;
  2938.                         }
  2939.  
  2940.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  2941.                     if (Error != eBuildInstrNoError)
  2942.                         {
  2943.                             return Error;
  2944.                         }
  2945.                     EnvelopeSetAccent1Amp(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  2946.  
  2947.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPACCENT1;
  2948.                     break;
  2949.  
  2950.                 case eKeywordAmpaccent2:
  2951.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPACCENT2) != 0)
  2952.                         {
  2953.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2954.                             return eBuildInstrMultipleEnvPointAmpAccent2;
  2955.                         }
  2956.  
  2957.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  2958.                     if (Error != eBuildInstrNoError)
  2959.                         {
  2960.                             return Error;
  2961.                         }
  2962.                     EnvelopeSetAccent2Amp(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  2963.  
  2964.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPACCENT2;
  2965.                     break;
  2966.  
  2967.                 case eKeywordAmpaccent3:
  2968.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPACCENT3) != 0)
  2969.                         {
  2970.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2971.                             return eBuildInstrMultipleEnvPointAmpAccent3;
  2972.                         }
  2973.  
  2974.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  2975.                     if (Error != eBuildInstrNoError)
  2976.                         {
  2977.                             return Error;
  2978.                         }
  2979.                     EnvelopeSetAccent3Amp(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  2980.  
  2981.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPACCENT3;
  2982.                     break;
  2983.  
  2984.                 case eKeywordAmpaccent4:
  2985.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPACCENT4) != 0)
  2986.                         {
  2987.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  2988.                             return eBuildInstrMultipleEnvPointAmpAccent4;
  2989.                         }
  2990.  
  2991.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  2992.                     if (Error != eBuildInstrNoError)
  2993.                         {
  2994.                             return Error;
  2995.                         }
  2996.                     EnvelopeSetAccent4Amp(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  2997.  
  2998.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPACCENT4;
  2999.                     break;
  3000.  
  3001.                 case eKeywordAmpfreq:
  3002.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_AMPFREQ) != 0)
  3003.                         {
  3004.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3005.                             return eBuildInstrMultipleEnvPointAmpFreq;
  3006.                         }
  3007.  
  3008.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3009.                     if (Error != eBuildInstrNoError)
  3010.                         {
  3011.                             return Error;
  3012.                         }
  3013.                     EnvelopeSetFreqAmpRolloff(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3014.  
  3015.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3016.                     if (Error != eBuildInstrNoError)
  3017.                         {
  3018.                             return Error;
  3019.                         }
  3020.                     EnvelopeSetFreqAmpNormalization(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3021.  
  3022.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_AMPFREQ;
  3023.                     break;
  3024.  
  3025.                 case eKeywordRateaccent1:
  3026.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEACCENT1) != 0)
  3027.                         {
  3028.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3029.                             return eBuildInstrMultipleEnvPointRateAccent1;
  3030.                         }
  3031.  
  3032.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3033.                     if (Error != eBuildInstrNoError)
  3034.                         {
  3035.                             return Error;
  3036.                         }
  3037.                     EnvelopeSetAccent1Rate(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3038.  
  3039.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEACCENT1;
  3040.                     break;
  3041.  
  3042.                 case eKeywordRateaccent2:
  3043.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEACCENT2) != 0)
  3044.                         {
  3045.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3046.                             return eBuildInstrMultipleEnvPointRateAccent2;
  3047.                         }
  3048.  
  3049.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3050.                     if (Error != eBuildInstrNoError)
  3051.                         {
  3052.                             return Error;
  3053.                         }
  3054.                     EnvelopeSetAccent2Rate(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3055.  
  3056.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEACCENT2;
  3057.                     break;
  3058.  
  3059.                 case eKeywordRateaccent3:
  3060.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEACCENT3) != 0)
  3061.                         {
  3062.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3063.                             return eBuildInstrMultipleEnvPointRateAccent3;
  3064.                         }
  3065.  
  3066.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3067.                     if (Error != eBuildInstrNoError)
  3068.                         {
  3069.                             return Error;
  3070.                         }
  3071.                     EnvelopeSetAccent3Rate(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3072.  
  3073.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEACCENT3;
  3074.                     break;
  3075.  
  3076.                 case eKeywordRateaccent4:
  3077.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEACCENT4) != 0)
  3078.                         {
  3079.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3080.                             return eBuildInstrMultipleEnvPointRateAccent4;
  3081.                         }
  3082.  
  3083.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3084.                     if (Error != eBuildInstrNoError)
  3085.                         {
  3086.                             return Error;
  3087.                         }
  3088.                     EnvelopeSetAccent4Rate(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3089.  
  3090.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEACCENT4;
  3091.                     break;
  3092.  
  3093.                 case eKeywordRatefreq:
  3094.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_RATEFREQ) != 0)
  3095.                         {
  3096.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3097.                             return eBuildInstrMultipleEnvPointRateFreq;
  3098.                         }
  3099.  
  3100.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3101.                     if (Error != eBuildInstrNoError)
  3102.                         {
  3103.                             return Error;
  3104.                         }
  3105.                     EnvelopeSetFreqRateRolloff(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3106.  
  3107.                     Error = ParseNumber(Scanner,ErrorLine,&Number);
  3108.                     if (Error != eBuildInstrNoError)
  3109.                         {
  3110.                             return Error;
  3111.                         }
  3112.                     EnvelopeSetFreqRateNormalization(Envelope,Number,GetEnvelopeNumFrames(Envelope) - 1);
  3113.  
  3114.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_RATEFREQ;
  3115.                     break;
  3116.  
  3117.                 case eKeywordExponential:
  3118.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_CURVE) != 0)
  3119.                         {
  3120.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3121.                             return eBuildInstrMultipleEnvPointCurveSpec;
  3122.                         }
  3123.  
  3124.                     EnvelopeSetPhaseTransitionType(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  3125.                         eEnvelopeLinearInDecibels);
  3126.  
  3127.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_CURVE;
  3128.                     break;
  3129.  
  3130.                 case eKeywordLinear:
  3131.                     if ((*OnceOnlyDefinitions & ENVPOINTDEFINITION_ONCEONLY_CURVE) != 0)
  3132.                         {
  3133.                             *ErrorLine = GetCurrentLineNumber(Scanner);
  3134.                             return eBuildInstrMultipleEnvPointCurveSpec;
  3135.                         }
  3136.  
  3137.                     EnvelopeSetPhaseTransitionType(Envelope,GetEnvelopeNumFrames(Envelope) - 1,
  3138.                         eEnvelopeLinearInAmplitude);
  3139.  
  3140.                     *OnceOnlyDefinitions |= ENVPOINTDEFINITION_ONCEONLY_CURVE;
  3141.                     break;
  3142.             }
  3143.  
  3144.         return eBuildInstrNoError;
  3145.     }
  3146.  
  3147.  
  3148.  
  3149.  
  3150. /*   XX:   <modulation_dynamic>    ::= envelope ( <envelope_definition> ) */
  3151. /*                                     {lfo ( <lfo> )} */
  3152. /* FOLLOW SET: */
  3153. /*   originadjust, type */
  3154. static BuildInstrErrors            ParseModulationDynamic(LFOListSpecRec** LFOListOut,
  3155.                                                             EnvelopeRec** EnvelopeOut, ScannerRec* Scanner,
  3156.                                                             long* ErrorLine, struct WaveTableListRec* WaveTableList,
  3157.                                                             struct AlgoWaveTableListRec* AlgoWaveTableList)
  3158.     {
  3159.         BuildInstrErrors                    Error;
  3160.         TokenRec*                                    Token;
  3161.         unsigned long                            Required;
  3162.         EnvelopeRec*                            Envelope;
  3163.         LFOListSpecRec*                        LFOList;
  3164.         LFOSpecRec*                                LFO;
  3165.  
  3166.         Envelope = NewEnvelope();
  3167.         if (Envelope == NIL)
  3168.             {
  3169.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3170.                 return eBuildInstrOutOfMemory;
  3171.             }
  3172.         LFOList = NewLFOListSpecifier();
  3173.         if (LFOList == NIL)
  3174.             {
  3175.                 DisposeEnvelope(Envelope);
  3176.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3177.                 return eBuildInstrOutOfMemory;
  3178.             }
  3179.  
  3180.         Token = GetNextToken(Scanner);
  3181.         if (Token == NIL)
  3182.             {
  3183.                 DisposeEnvelope(Envelope);
  3184.                 DisposeLFOListSpecifier(LFOList);
  3185.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3186.                 return eBuildInstrOutOfMemory;
  3187.             }
  3188.         if ((GetTokenType(Token) != eTokenKeyword)
  3189.             || (GetTokenKeywordTag(Token) != eKeywordEnvelope))
  3190.             {
  3191.                 DisposeEnvelope(Envelope);
  3192.                 DisposeLFOListSpecifier(LFOList);
  3193.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3194.                 return eBuildInstrExpectedEnvelope;
  3195.             }
  3196.  
  3197.         Token = GetNextToken(Scanner);
  3198.         if (Token == NIL)
  3199.             {
  3200.                 DisposeEnvelope(Envelope);
  3201.                 DisposeLFOListSpecifier(LFOList);
  3202.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3203.                 return eBuildInstrOutOfMemory;
  3204.             }
  3205.         if (GetTokenType(Token) != eTokenOpenParen)
  3206.             {
  3207.                 DisposeEnvelope(Envelope);
  3208.                 DisposeLFOListSpecifier(LFOList);
  3209.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3210.                 return eBuildInstrExpectedOpenParen;
  3211.             }
  3212.  
  3213.         Required = 0;
  3214.         Error = ParseEnvelopeDefinition(Envelope,Scanner,ErrorLine,&Required,0);
  3215.         if (Error != eBuildInstrNoError)
  3216.             {
  3217.                 DisposeEnvelope(Envelope);
  3218.                 DisposeLFOListSpecifier(LFOList);
  3219.                 return Error;
  3220.             }
  3221.         if (Required != ENVELOPEDEFINITION_REQUIREDMASK)
  3222.             {
  3223.                 DisposeEnvelope(Envelope);
  3224.                 DisposeLFOListSpecifier(LFOList);
  3225.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3226.                 return eBuildInstrSomeRequiredEnvelopeParamsMissing;
  3227.             }
  3228.  
  3229.         Token = GetNextToken(Scanner);
  3230.         if (Token == NIL)
  3231.             {
  3232.                 DisposeEnvelope(Envelope);
  3233.                 DisposeLFOListSpecifier(LFOList);
  3234.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3235.                 return eBuildInstrOutOfMemory;
  3236.             }
  3237.         if (GetTokenType(Token) != eTokenCloseParen)
  3238.             {
  3239.                 DisposeEnvelope(Envelope);
  3240.                 DisposeLFOListSpecifier(LFOList);
  3241.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3242.                 return eBuildInstrExpectedCloseParen;
  3243.             }
  3244.  
  3245.         /* we should have used tail recursion, but that's a pain for an ad-hoc addition */
  3246.      LoopPoint:
  3247.  
  3248.         Token = GetNextToken(Scanner);
  3249.         if (Token == NIL)
  3250.             {
  3251.                 DisposeEnvelope(Envelope);
  3252.                 DisposeLFOListSpecifier(LFOList);
  3253.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3254.                 return eBuildInstrOutOfMemory;
  3255.             }
  3256.         if ((GetTokenType(Token) == eTokenKeyword)
  3257.             && ((GetTokenKeywordTag(Token) == eKeywordOriginadjust)
  3258.                 || (GetTokenKeywordTag(Token) == eKeywordType)))
  3259.             {
  3260.                 UngetToken(Scanner,Token);
  3261.                 *EnvelopeOut = Envelope;
  3262.                 *LFOListOut = LFOList;
  3263.                 return eBuildInstrNoError;
  3264.             }
  3265.  
  3266.         if ((GetTokenType(Token) != eTokenKeyword)
  3267.             || (GetTokenKeywordTag(Token) != eKeywordLfo))
  3268.             {
  3269.                 DisposeEnvelope(Envelope);
  3270.                 DisposeLFOListSpecifier(LFOList);
  3271.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3272.                 return eBuildInstrExpectedLFO;
  3273.             }
  3274.  
  3275.         Token = GetNextToken(Scanner);
  3276.         if (Token == NIL)
  3277.             {
  3278.                 DisposeEnvelope(Envelope);
  3279.                 DisposeLFOListSpecifier(LFOList);
  3280.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3281.                 return eBuildInstrOutOfMemory;
  3282.             }
  3283.         if (GetTokenType(Token) != eTokenOpenParen)
  3284.             {
  3285.                 DisposeEnvelope(Envelope);
  3286.                 DisposeLFOListSpecifier(LFOList);
  3287.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3288.                 return eBuildInstrExpectedOpenParen;
  3289.             }
  3290.  
  3291.         LFO = NewLFOSpecifier();
  3292.         if (LFO == NIL)
  3293.             {
  3294.                 DisposeEnvelope(Envelope);
  3295.                 DisposeLFOListSpecifier(LFOList);
  3296.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3297.                 return eBuildInstrOutOfMemory;
  3298.             }
  3299.         Required = 0;
  3300.         Error = ParseLfoDefinition(LFO,Scanner,ErrorLine,&Required,0,WaveTableList,
  3301.             AlgoWaveTableList);
  3302.         if (Error != eBuildInstrNoError)
  3303.             {
  3304.                 DisposeLFOSpecifier(LFO);
  3305.                 DisposeEnvelope(Envelope);
  3306.                 DisposeLFOListSpecifier(LFOList);
  3307.                 return Error;
  3308.             }
  3309.         if (Required != LFODEFINITION_REQUIREDMASK)
  3310.             {
  3311.                 DisposeLFOSpecifier(LFO);
  3312.                 DisposeEnvelope(Envelope);
  3313.                 DisposeLFOListSpecifier(LFOList);
  3314.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3315.                 return eBuildInstrSomeRequiredLFOParamsMissing;
  3316.             }
  3317.         if (!LFOListSpecAppendNewEntry(LFOList,LFO))
  3318.             {
  3319.                 DisposeLFOSpecifier(LFO);
  3320.                 DisposeEnvelope(Envelope);
  3321.                 DisposeLFOListSpecifier(LFOList);
  3322.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3323.                 return eBuildInstrOutOfMemory;
  3324.             }
  3325.  
  3326.         Token = GetNextToken(Scanner);
  3327.         if (Token == NIL)
  3328.             {
  3329.                 DisposeEnvelope(Envelope);
  3330.                 DisposeLFOListSpecifier(LFOList);
  3331.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3332.                 return eBuildInstrOutOfMemory;
  3333.             }
  3334.         if (GetTokenType(Token) != eTokenCloseParen)
  3335.             {
  3336.                 DisposeEnvelope(Envelope);
  3337.                 DisposeLFOListSpecifier(LFOList);
  3338.                 *ErrorLine = GetCurrentLineNumber(Scanner);
  3339.                 return eBuildInstrExpectedCloseParen;
  3340.             }
  3341.  
  3342.         goto LoopPoint;
  3343.     }
  3344.  
  3345.  
  3346.  
  3347.  
  3348. /* get a static null terminated string describing the error */
  3349. char*                                                BuildInstrGetErrorMessageText(BuildInstrErrors ErrorCode)
  3350.     {
  3351.         char*                                            S EXECUTE(= (char*)0x81818181);
  3352.  
  3353.         switch (ErrorCode)
  3354.             {
  3355.                 default:
  3356.                     EXECUTE(PRERR(ForceAbort,"BuildInstrGetErrorMessageText:  bad error code"));
  3357.                     break;
  3358.                 case eBuildInstrOutOfMemory:
  3359.                     S = "Out of memory";
  3360.                     break;
  3361.                 case eBuildInstrUnexpectedInput:
  3362.                     S = "Unexpected end of text";
  3363.                     break;
  3364.                 case eBuildInstrExpectedInstrument:
  3365.                     S = "Expected 'instrument'";
  3366.                     break;
  3367.                 case eBuildInstrExpectedOpenParen:
  3368.                     S = "Expected '"OPAREN"'";
  3369.                     break;
  3370.                 case eBuildInstrExpectedCloseParen:
  3371.                     S = "Expected '"CPAREN"'";
  3372.                     break;
  3373.                 case eBuildInstrSomeRequiredInstrParamsMissing:
  3374.                     S = "Some required instrument parameters have not been specified";
  3375.                     break;
  3376.                 case eBuildInstrExpectedSemicolon:
  3377.                     S = "Expected ';'";
  3378.                     break;
  3379.                 case eBuildInstrExpectedInstrumentMember:
  3380.                     S = "Expected 'loudness', 'frequencylfo', or 'oscillator'";
  3381.                     break;
  3382.                 case eBuildInstrMultipleInstrLoudness:
  3383.                     S = "Instrument parameter 'loudness' has already been specified";
  3384.                     break;
  3385.                 case eBuildInstrSomeRequiredLFOParamsMissing:
  3386.                     S = "Some required LFO parameters have not been specified";
  3387.                     break;
  3388.                 case eBuildInstrSomeRequiredOscillatorParamsMissing:
  3389.                     S = "Some required oscillator parameters have not been specified";
  3390.                     break;
  3391.                 case eBuildInstrExpectedNumber:
  3392.                     S = "Expected a number";
  3393.                     break;
  3394.                 case eBuildInstrExpectedStringOrIdentifier:
  3395.                     S = "Expected a string or identifier";
  3396.                     break;
  3397.                 case eBuildInstrExpectedLFOMember:
  3398.                     S = "Expected 'freqenvelope', 'ampenvelope', 'oscillator', 'modulation', "
  3399.                         "'linear', or 'exponential'";
  3400.                     break;
  3401.                 case eBuildInstrMultipleLFOFreqEnvelope:
  3402.                     S = "LFO parameter 'freqenvelope' has already been specified";
  3403.                     break;
  3404.                 case eBuildInstrSomeRequiredEnvelopeParamsMissing:
  3405.                     S = "Some required envelope parameters have not been specified";
  3406.                     break;
  3407.                 case eBuildInstrMultipleLFOAmpEnvelope:
  3408.                     S = "LFO parameter 'ampenvelope' has already been specified";
  3409.                     break;
  3410.                 case eBuildInstrMultipleLFOOscillatorType:
  3411.                     S = "LFO parameter 'oscillator' has already been specified";
  3412.                     break;
  3413.                 case eBuildInstrExpectedLFOOscillatorType:
  3414.                     S = "Expected 'constant', 'signsine', 'plussine', 'signtriangle', "
  3415.                         "'plustriangle', 'signsquare', 'plussquare', 'signramp', 'plusramp', "
  3416.                         "'signlinfuzz', or 'pluslinfuzz'";
  3417.                     break;
  3418.                 case eBuildInstrMultipleLFOModulationType:
  3419.                     S = "LFO parameter 'modulation' has already been specified";
  3420.                     break;
  3421.                 case eBuildInstrMultipleLFOAddingMode:
  3422.                     S = "LFO adding mode ('linear' or 'exponential') has already been specified";
  3423.                     break;
  3424.                 case eBuildInstrExpectedLFOModulationType:
  3425.                     S = "Expected 'additive', 'multiplicative', or 'inversemult'";
  3426.                     break;
  3427.                 case eBuildInstrExpectedOscillatorMember:
  3428.                     S = "Expected 'type', 'samplelist', 'modulators', 'loudness', "
  3429.                         "'freqmultiplier', 'freqdivisor', 'makeoutput', 'loudnessenvelope', "
  3430.                         "'loudnesslfo', 'indexenvelope', 'indexlfo', 'stereobias', "
  3431.                         "or 'displacement'";
  3432.                     break;
  3433.                 case eBuildInstrMultipleOscType:
  3434.                     S = "Oscillator parameter 'type' has already been specified";
  3435.                     break;
  3436.                 case eBuildInstrMultipleOscSampleList:
  3437.                     S = "Oscillator parameter 'samplelist' has already been specified";
  3438.                     break;
  3439.                 case eBuildInstrMultipleOscModulators:
  3440.                     S = "Oscillator parameter 'modulators' has already been specified";
  3441.                     break;
  3442.                 case eBuildInstrMultipleOscLoudness:
  3443.                     S = "Oscillator parameter 'loudness' has already been specified";
  3444.                     break;
  3445.                 case eBuildInstrMultipleOscFreqMultiplier:
  3446.                     S = "Oscillator parameter 'freqmultiplier' has already been specified";
  3447.                     break;
  3448.                 case eBuildInstrMultipleOscFreqDivisor:
  3449.                     S = "Oscillator parameter 'freqdivisor' has already been specified";
  3450.                     break;
  3451.                 case eBuildInstrMultipleOscMakeOutput:
  3452.                     S = "Oscillator parameter 'makeoutput' has already been specified";
  3453.                     break;
  3454.                 case eBuildInstrMultipleOscLoudnessEnvelope:
  3455.                     S = "Oscillator parameter 'loudnessenvelope' has already been specified";
  3456.                     break;
  3457.                 case eBuildInstrMultipleOscIndexEnvelope:
  3458.                     S = "Oscillator parameter 'indexenvelope' has already bee specified";
  3459.                     break;
  3460.                 case eBuildInstrExpectedOscType:
  3461.                     S = "Expected 'sampled' or 'wavetable'";
  3462.                     break;
  3463.                 case eBuildInstrExpectedInteger:
  3464.                     S = "Expected an integer";
  3465.                     break;
  3466.                 case eBuildInstrExpectedBoolean:
  3467.                     S = "Expected 'true' or 'false'";
  3468.                     break;
  3469.                 case eBuildInstrExpectedEnvelopeMember:
  3470.                     S = "Expected 'totalscaling' or 'points'";
  3471.                     break;
  3472.                 case eBuildInstrMultipleEnvTotalScaling:
  3473.                     S = "Envelope parameter 'totalscaling' has already been specified";
  3474.                     break;
  3475.                 case eBuildInstrMultipleEnvPoints:
  3476.                     S = "Envelope parameter 'points' has already been specified";
  3477.                     break;
  3478.                 case eBuildInstrExpectedSource:
  3479.                     S = "Expected 'source'";
  3480.                     break;
  3481.                 case eBuildInstrExpectedScale:
  3482.                     S = "Expected 'scale'";
  3483.                     break;
  3484.                 case eBuildInstrExpectedOriginadjust:
  3485.                     S = "Expected 'originadjust'";
  3486.                     break;
  3487.                 case eBuildInstrExpectedType:
  3488.                     S = "Expected 'type'";
  3489.                     break;
  3490.                 case eBuildInstrExpectedModulationTypeSpecifier:
  3491.                     S = "Expected 'additive' or 'multiplicative'";
  3492.                     break;
  3493.                 case eBuildInstrExpectedTarget:
  3494.                     S = "Expected 'target'";
  3495.                     break;
  3496.                 case eBuildInstrExpectedModulationTargetSpecifier:
  3497.                     S = "Expected 'phasegen' or 'output'";
  3498.                     break;
  3499.                 case eBuildInstrExpectedDelayOrOrigin:
  3500.                     S = "Expected 'delay' or 'origin'";
  3501.                     break;
  3502.                 case eBuildInstrExpectedLevel:
  3503.                     S = "Expected 'level'";
  3504.                     break;
  3505.                 case eBuildInstrExpectedEnvPointMember:
  3506.                     S = "Expected 'sustainpoint', 'sustainpointnoskip', 'releasepoint', "
  3507.                         "'releasepointnoskip', 'ampaccent1', 'ampaccent2', 'ampaccent3', "
  3508.                         "'ampaccent4', 'ampfreq', 'rateaccent1', 'rateaccent2', 'rateaccent3', "
  3509.                         "'rateaccent4', 'ratefreq', 'exponential', or 'linear'";
  3510.                     break;
  3511.                 case eBuildInstrExpectedIntBetween1And3:
  3512.                     S = "Expected an integer in the range [1..3]";
  3513.                     break;
  3514.                 case eBuildInstrEnvSustainPointAlreadyDefined:
  3515.                     S = "That envelope sustain point has already been specified";
  3516.                     break;
  3517.                 case eBuildInstrMultipleEnvPointAmpAccent1:
  3518.                     S = "Envelope parameter 'ampaccent1' has already been specified";
  3519.                     break;
  3520.                 case eBuildInstrMultipleEnvPointAmpAccent2:
  3521.                     S = "Envelope parameter 'ampaccent2' has already been specified";
  3522.                     break;
  3523.                 case eBuildInstrMultipleEnvPointAmpAccent3:
  3524.                     S = "Envelope parameter 'ampaccent3' has already been specified";
  3525.                     break;
  3526.                 case eBuildInstrMultipleEnvPointAmpAccent4:
  3527.                     S = "Envelope parameter 'ampaccent4' has already been specified";
  3528.                     break;
  3529.                 case eBuildInstrMultipleEnvPointAmpFreq:
  3530.                     S = "Envelope parameter 'ampfreq' has already been specified";
  3531.                     break;
  3532.                 case eBuildInstrMultipleEnvPointRateAccent1:
  3533.                     S = "Envelope parameter 'rateaccent1' has already been specified";
  3534.                     break;
  3535.                 case eBuildInstrMultipleEnvPointRateAccent2:
  3536.                     S = "Envelope parameter 'rateaccent2' has already been specified";
  3537.                     break;
  3538.                 case eBuildInstrMultipleEnvPointRateAccent3:
  3539.                     S = "Envelope parameter 'rateaccent3' has already been specified";
  3540.                     break;
  3541.                 case eBuildInstrMultipleEnvPointRateAccent4:
  3542.                     S = "Envelope parameter 'rateaccent4' has already been specified";
  3543.                     break;
  3544.                 case eBuildInstrMultipleEnvPointRateFreq:
  3545.                     S = "Envelope parameter 'ratefreq' has already been specified";
  3546.                     break;
  3547.                 case eBuildInstrMultipleEnvPointCurveSpec:
  3548.                     S = "Envelope parameter 'exponential' or 'linear' has "
  3549.                         "already been specified";
  3550.                     break;
  3551.                 case eBuildInstrUnresolvedOscillatorReferences:
  3552.                     S = "Some named oscillator references in modulation lists can not be "
  3553.                         "resolved: the named oscillators do not exist";
  3554.                     break;
  3555.                 case eBuildInstrSomeSamplesDontExist:
  3556.                     S = "Some named samples or algorithmic samples do not exist";
  3557.                     break;
  3558.                 case eBuildInstrSomeWaveTablesDontExist:
  3559.                     S = "Some named wave tables or algorithmic wave tables do not exist";
  3560.                     break;
  3561.                 case eBuildInstrExpectedEnvelope:
  3562.                     S = "Expected 'envelope'";
  3563.                     break;
  3564.                 case eBuildInstrExpectedLFO:
  3565.                     S = "Expected 'lfo'";
  3566.                     break;
  3567.                 case eBuildInstrMultipleOscStereoBias:
  3568.                     S = "Oscillator parameter 'stereobias' has already been specified";
  3569.                     break;
  3570.                 case eBuildInstrMultipleOscDisplacement:
  3571.                     S = "Oscillator parameter 'displacement' has already been specified";
  3572.                     break;
  3573.                 case eBuildInstrMultipleOscSurroundBias:
  3574.                     S = "Oscillator parameter 'surroundbias' has already been specified";
  3575.                     break;
  3576.             }
  3577.  
  3578.         return S;
  3579.     }
  3580.